Launching Soon 30 lessons · 30 days

PS30 PowerShell from Zero
to Professional

One lesson lands in your inbox every morning. Each one is short enough to read with your coffee and practical enough to use before lunch. By day 30, you'll have a toolkit you built yourself.

30 lessons
~10 min per day
free forever

Learn at inbox speed

PS30 is an email course, not a platform you have to log into. Each morning you get one focused lesson with a hands-on exercise. No videos, no subscriptions, no pressure.

Delivered to you

A new lesson arrives each morning. Read it in your email client, no login required. Each one is self-contained — miss a day, just pick back up.

Open your terminal

Every lesson ends with a hands-on exercise you can run in minutes. Type the commands. See the output. Build the muscle memory that makes skills stick.

Go deeper with ASFS

Many lessons link to a full module on this site where you can dig further. PS30 teaches the concept; the ASFS module gives you the depth.

Days 1–7 Beginner

Open the terminal. Run commands. Read output without fear.

Days 8–14 Comfortable

Understand objects, manipulate data, store results in variables.

Days 15–21 Scripting

Write logic that branches, loops, reads files, and outputs CSV.

Days 22–28 Functional

Build reusable functions, handle errors, call APIs, install modules.

Days 29–30 Professional

Deploy scheduled automation and ship your personal toolkit.

30 Days, Zero Fluff

Every lesson is a single, focused idea with a practical exercise. Lessons marked with a module badge have a full companion module on this site — more code, more context, more examples.

Week 1

Your First Commands

The terminal stops being scary

7 lessons

Opening PowerShell

Launch your first terminal, run your first command, and understand exactly what just happened.

  • What PowerShell actually is (and isn't)
  • Opening the terminal on any Windows machine
  • Running Get-Date — your first real command
Day 2

Command Anatomy

Every PowerShell command follows the same Verb-Noun pattern. Once you see it, you can't unsee it.

  • The Verb-Noun naming convention
  • Reading command output without panicking
  • Tab completion — your new best friend

Getting Help

PowerShell ships with a full documentation system. No Stack Overflow required for the basics.

  • Get-Help and how to read it
  • Update-Help for fresh docs
  • -Examples: the flag you'll use constantly
Day 4

Navigating the Filesystem

Move around your machine from the terminal. Set-Location, Get-Location, and why they beat the GUI.

  • Set-Location (cd) and Get-Location (pwd)
  • Absolute vs relative paths
  • Push-Location and Pop-Location for safe navigation
Day 5

Listing & Finding Files

Get-ChildItem is the Swiss Army knife of file discovery. Today you'll use it six different ways.

  • Get-ChildItem basics and -Recurse
  • Filtering by extension with -Filter
  • Finding files modified in the last N days

The Pipeline

The pipe character | is the most powerful key on your keyboard. Here's why it changes everything.

  • What the pipeline actually does
  • Chaining three commands together
  • Why order matters in a pipeline
Day 7

Week 1 Review

Consolidate the week with a real one-liner challenge: find all log files older than 30 days and count them.

  • Building your first real one-liner
  • Reading command output like a pro
  • The 5 commands you'll use every single day
Week 2

Objects & Data

PowerShell thinks differently — so will you

7 lessons

Everything Is an Object

PowerShell doesn't pass text between commands — it passes rich objects with properties and methods.

  • Why objects beat plain text
  • Get-Member: inspecting what you're working with
  • Dot notation to access properties

Select & Format

Stop looking at walls of output. Select-Object and Format-Table give you exactly the columns you want.

  • Select-Object -Property for targeted output
  • Format-Table vs Format-List
  • Calculated properties with @{Name=; Expression=}
Day 10

Sorting & Measuring

Sort-Object, Group-Object, and Measure-Object — the analytics trio that turns raw data into answers.

  • Sort-Object by one or more properties
  • Group-Object to bucket results
  • Measure-Object for count, sum, average

Variables

Store anything in a variable: a string, a number, an entire directory listing. Variables make scripts real.

  • Declaring and using $variables
  • Variable types and automatic coercion
  • Best practices: meaningful names, not $x
Day 12

Strings in Depth

Strings are everywhere. Today: concatenation, interpolation, substrings, replace, split, and join.

  • Double-quoted vs single-quoted strings
  • String interpolation with $() expressions
  • -replace, -split, and -join operators
Day 13

Numbers & Dates

Arithmetic, comparisons, and date math. Calculate how many days until a deadline, or how old a file is.

  • Arithmetic and comparison operators
  • Working with [datetime] objects
  • New-TimeSpan and date arithmetic
Day 14

Arrays & Hashtables

Collect multiple values in an array. Map keys to values with a hashtable. Both are everywhere in real scripts.

  • Creating and indexing arrays
  • Hashtables as key-value stores
  • Iterating over both with ForEach
Week 3

Logic & Flow

Scripts that make decisions and repeat themselves

7 lessons

If / ElseIf / Else

Make your script smart. Branch on file existence, size, age, or any condition you can express.

  • If / ElseIf / Else syntax
  • Comparison: -eq, -ne, -gt, -lt, -like, -match
  • Testing file existence before acting on it

ForEach-Object

The pipeline's loop. Process every file, every user, every row — one object at a time.

  • ForEach-Object with $_ (process block)
  • The foreach() statement alternative
  • When to loop vs when to pipeline

While & Do Loops

Loop until a condition is met. Poll a service, retry an operation, wait for a file to appear.

  • while and do-while syntax
  • do-until for at-least-once logic
  • Avoiding infinite loops with safe exit conditions

Reading & Writing Files

Get-Content, Set-Content, Add-Content, Out-File. Text files are the universal glue of automation.

  • Get-Content line-by-line vs -Raw
  • Set-Content and Out-File differences
  • Appending without overwriting with Add-Content

CSV Data

Import a spreadsheet, process every row, export the results. This alone saves hours every week.

  • Import-Csv and the objects it creates
  • Modifying rows and exporting with Export-Csv
  • Real example: bulk rename from a spreadsheet

JSON

APIs speak JSON. PowerShell 7 speaks JSON fluently. ConvertFrom-Json and ConvertTo-Json are your translators.

  • ConvertFrom-Json to work with API responses
  • ConvertTo-Json for structured output
  • Navigating nested objects with dot notation
Day 21

Week 3 Project

Build a log parser: read a folder of .log files, extract lines matching a pattern, export a CSV summary.

  • Combining Get-Content, Where-Object, and Export-Csv
  • Select-String for pattern matching in files
  • Putting three weeks of skills together
Week 4

Scripting & Functions

Professional-grade code from scratch

7 lessons

Your First Function

Stop copy-pasting. A function wraps reusable logic behind a name you can call whenever you need it.

  • function keyword and basic syntax
  • Naming functions using Verb-Noun convention
  • Calling functions from the same script

Parameters & Validation

Functions that accept arguments are infinitely more useful. Add [Parameter(Mandatory)] and sleep easy.

  • param() block and type constraints
  • [Parameter(Mandatory)] and [ValidateSet()]
  • Default values and optional parameters

Try / Catch / Finally

Real scripts break on real systems. Catch the error, log it, decide whether to stop or keep going.

  • try / catch / finally structure
  • -ErrorAction Stop to make cmdlets catchable
  • Writing useful error messages with $_.Exception.Message

Saving & Running .ps1 Files

Graduate from the console to persistent scripts. Execution policy, dot-sourcing, and running scripts on a schedule.

  • Set-ExecutionPolicy and what it actually means
  • Running scripts: .\MyScript.ps1
  • Dot-sourcing to load functions into your session
Day 26

PowerShell Modules

Thousands of pre-built commands are one Install-Module away. Today you install your first module and use it.

  • Find-Module and Install-Module from PSGallery
  • Import-Module and Get-Command -Module
  • Building your first personal .psm1 module
Day 27

Regular Expressions

Patterns that match text. Sounds scary, is actually just a language for describing what you're looking for.

  • -match operator and $Matches variable
  • Select-String -Pattern for file searches
  • 5 regex patterns that cover 80% of real use cases
Day 28

Calling APIs

Invoke-RestMethod turns any REST API into PowerShell objects. Query the weather, your ticketing system, anything.

  • Invoke-RestMethod with GET and POST
  • Passing headers and auth tokens
  • Real example: query a public API, format the output
Week 5

Final Sprint

Ship something real

2 lessons

Real-World Automation

Scheduled tasks, Active Directory basics, and remote execution. The tools that separate a scripter from a sysadmin.

  • Register-ScheduledTask to run scripts on a timer
  • Active Directory with Get-ADUser and Get-ADGroup
  • Invoke-Command for remote execution

Your Personal Toolkit

You've done it. Day 30: build the utility module you'll actually use — the one tailored exactly to your job.

  • Identifying your top 3 repetitive tasks
  • Packaging your best functions into a module
  • Publishing to a local PSGallery or your team's repo

Be the first to know when we launch

PS30 is in its final stages. Drop your email and we'll send you a note the moment Day 1 is ready to land in your inbox. No spam, no placeholder content — just a single message when it's live.

The full 30-day curriculum above is the real thing — no filler. You're signing up for exactly what you see.