Home / PowerShell
PowerShell
PowerShell beyond first scripts: validated parameters and pipeline input, modules with manifests and versions, error handling, providers, objects, text and data, jobs, and three working tools. Every example is run with the real interpreter.
Beginner PowerShell taught you to run commands and write small scripts. Intermediate PowerShell teaches you to build tools other people can trust: functions that validate their own input, modules with versions, errors that get handled instead of crashing the script, and jobs that run work in the background. This course turns one-off scripts into a toolkit.
Course contents
Work top to bottom — the sidebar is the course. Topics later in the list assume the ones before them.
PowerShell Intermediate Introduction
Intermediate · ⏱ 3 min · standalone lesson
Advanced Functions
- PowerShell Cmdlet Binding
- PowerShell Parameter Validation
- PowerShell Parameter Sets
- PowerShell Pipeline Input
- PowerShell Common Parameters
- PowerShell Splatting
- PowerShell Function Output
Modules in Depth
- PowerShell Module Manifests
- PowerShell Exporting Members
- PowerShell Module Versioning
- PowerShell Module Privacy
- PowerShell Module Paths
Error Handling in Depth
- PowerShell Terminating vs Non-Terminating Errors
- PowerShell Try Catch Finally
- PowerShell Error Records
- PowerShell Error Action Preference
- PowerShell Error Variable
- PowerShell Throwing Errors
Remoting at a First Look
Start: PowerShell Invoke-Command ❯Providers and Drives
- PowerShell Providers
- PowerShell FileSystem Drives
- PowerShell Special Drives
- PowerShell Environment Drive
- PowerShell Custom Drives
Objects and Formatting
- PowerShell Calculated Properties
- PowerShell Grouping Data
- PowerShell Comparing Objects
- PowerShell String Formatting
- PowerShell Classes First Look
Text and Data
- PowerShell Regular Expressions in Depth
- PowerShell JSON Data
- PowerShell CSV Data
- PowerShell XML Data
Scripting Best Practices
- PowerShell Script Structure
- PowerShell Comment-Based Help
- PowerShell Strict Mode
- PowerShell PSScriptAnalyzer Concepts
Jobs and Automation
- PowerShell Background Jobs
- PowerShell Job Patterns
- PowerShell Profiles
- PowerShell Automation Scripts
PowerShell Project: Log Analyzer
Intermediate · ⏱ 6 min · standalone lesson
PowerShell Project: Admin Toolkit
Intermediate · ⏱ 6 min · standalone lesson
PowerShell Project: Backup Tool
Intermediate · ⏱ 7 min · standalone lesson
Take PowerShell further
This course picks up where the beginner course stops. You already know cmdlets, pipelines, variables, functions, files, and modules at a first look. Here each of those ideas grows teeth: a function gains parameter validation and pipeline binding, a module gains a manifest and a version number, and error handling grows from one try block into a deliberate strategy.
The emphasis is on scripts that survive contact with real machines. A script that only works when every input is perfect is a demo, not a tool. So you will learn to reject bad input early, to choose between stopping and carrying on when something fails, and to report what happened in words a human can act on.
Every example in the 47 lessons was run with the genuine PowerShell interpreter before publication, and what the page shows as output is what that run printed. Each lesson ends with a practice question whose answer explains the reasoning, not just the letter.
What you will learn
The path moves from using commands to building tools. By the last lesson, you will be able to do all of this in PowerShell:
- Write advanced functions with cmdlet binding, validated parameters, parameter sets, and full pipeline input.
- Control the common parameters: error action, WhatIf dry runs, confirmation prompts, and verbose output.
- Pass many arguments cleanly with splatting, and keep a function's output exactly what you intended.
- Ship modules properly with manifests, exported members, version folders, and private helpers.
- Tell terminating errors from non-terminating ones, and handle each with try, catch, and finally.
- Read error records, set error preferences, capture errors in variables, and throw your own.
- Run commands through Invoke-Command, share values with the using scope, and know what true remoting still needs.
- Browse providers and drives, including the variable, alias, environment, and custom drives you create.
- Shape objects with calculated properties, grouping, comparison, string formatting, and a first class.
- Work with text and data: regular expressions, JSON, CSV, and XML.
- Structure scripts well, document functions with comment-based help, and catch mistakes early with strict mode.
- Run work in the background with jobs, throttle batches of jobs, and automate routine checks.
- Finish with three working tools: a log analyzer, an admin toolkit module, and a backup tool with a WhatIf mode.
Who this PowerShell course is for
This course is for readers who already write PowerShell and want their scripts to hold up. If you have finished the beginner course, or you write scripts at work and keep hitting their limits, you are ready.
It suits system administrators, support engineers, and anyone automating Windows or Linux machines with PowerShell. The skills transfer to any scripting work where reliability matters more than cleverness.
The 47 lessons add up to 160 minutes of lesson time, counted from the per-lesson estimates. Take them in order: the module lessons assume the function lessons, and the automation lessons assume everything before them.
How this course works
Read the lessons in order. Each one introduces a small number of new ideas and proves each with a runnable example, so nothing arrives unexplained.
Outputs on the page are real. When a lesson shows a count, a message, or an error, that text came from running the code printed just above it.
Try each closing exercise before revealing its answer. A wrong answer still moves you forward, because the explanation shows the reasoning step by step.
Your place in the course is remembered in your browser, so a later visit returns you to the next lesson you have not finished.
Frequently asked questions
Do I need to finish the beginner course first?
Yes, in practice. This course builds directly on cmdlets, pipelines, variables, functions, files, and first-look modules, and it does not reteach them. If those ideas are fresh for you, start with the beginner course and come back.
Is this PowerShell course free?
Yes. You can read all 47 lessons without an account and without paying anything.
Does PowerShell Intermediate cover remoting to other computers?
It covers remoting at a first look. You will run Invoke-Command and learn the using scope on your own machine, and the course states plainly what a real remote connection still requires. No remote host is contacted in any lesson, because this course runs entirely on one machine.
How long does PowerShell Intermediate take?
The 47 lessons total 160 minutes of lesson time, summed from the per-lesson estimates. Most readers spread that across several sittings, a few lessons at a time.
What will I be able to build when I finish?
The course ends with three finished tools: a log analyzer that counts and reports log levels, an admin toolkit module with exported functions, and a backup tool that verifies its own copies and supports WhatIf dry runs. From there, you can start building tools for the repetitive jobs on your own machines.
Does the course need Windows?
No. Every example was run on Linux with PowerShell 7.5.3, and the same commands run on Windows and macOS. Two topics are called out as platform-shaped: scheduled jobs are not available on Linux PowerShell, so the course teaches job patterns instead, and remoting requirements differ by platform.
Next steps
- Bash ❯ — Bash Intermediate runs 46 lessons through the other major shell at the same depth: functions, error handling, and scripting patterns in a text-passing shell, which sharpens the contrast with PowerShell objects.
- Go Intermediate ❯ — Go Intermediate runs 34 lessons through a compiled language at the same level. It fits the moment a script deserves to become a fast, single-file program.
- Python Advanced ❯ — Python Advanced runs 102 lessons through a general-purpose language at full depth. It is the path when your automation grows into larger programs with tests and packages.