2021 Schedule

Featured Speakers
Event Agenda
All times are in PDT

Join PowerShell inventor and Technical Fellow Jeffrey Snover and Lead PM Joey Aiello as they discuss the upcoming long-term servicing release (LTS) of PowerShell 7.2! Learn about the community-driven investments the Team is making in this major release like SecretManagement, DSC, Crescendo, and more. Your voice matters in the success of PowerShell, learn about new improvements to the contribution process with Working Groups to get your voice heard.

In August 2020, GitHub added support for PowerShell within GitHub Composite Actions for all of their runners, including Ubuntu, Mac OS, and Windows. GitHub Actions allow you to create reusable actions using shell scripts and even mix multiple shell languages in the same action. You probably have a lot of shell scripts to automate many tasks, now you can easily turn them into action and reuse them for different workflows.

This Action-packed presentation will show you how fun and useful this new GitHub feature can be. Combined with Docker containers, the possibilities are endless.

There are a myriad of examples of code that provides a bad user experience. Typically, these are very simple issues to resolve, they just require a little thought and planning. Come find out how to write experiences with your users in mind.

Writing good code goes beyond how easy it is to read and follow. This talk focuses in on some key considerations you should think about prior to starting your next project. 

We'll discuss several things in this talk including but not limited to the following:

- Flow

- Parameter design

- Help systems

- Testing

- Overall Usability (How the user will interact with the software)

I hope you'll join me as we discuss making your next project the best user experience possible.

Get on the cutting edge by implementing infrastructure as code for your SQL Server environment. Using PowerShell Desired State Configuration (DSC) we’ll look at how to take a newly built Windows Server and get it ready for prime time while discussing the benefits associated with infrastructure as code.

   * Setup Pre-Requisites

   * Install SQL Server

   * Configure SQL Server

   * Make SQL Server Application Ready


Learn how to leverage PowerShell to interact with the Microsoft Graph REST API. The Microsoft Graph API is the gateway to data and intelligence in Microsoft 365 and offers a single endpoint that provides access to Exchange, Teams, SharePoint, AzureAD, Outlook, and more.

In this talk, we will learn how to leverage PowerShell to connect to and work in REST API's. Using PowerShell's Invoke-RestMethod we can interact directly with Microsoft's GRAPH API.

Learn how to:

- Manage Microsoft Teams including posting messages

- Manage Azure Active Directory

- Parse users e-mail and send messages

- Get users calendar events

- Upload data to SharePoint

- Whole lot more!


Incidents happen and most depend on commercial tools but they may not always be available. Luckily, we are not out of luck as PowerShell can and is being used for incident response. We will demo how the language can aid you in your next incident including a few frameworks that I developed.

There will come a point where every organization will likely be compromised. To be able to identify it before or as it is happening, most acquire technology to help identify any malicious behavior but that technology comes with a price tag that not every organization can afford. With most organizations having Windows systems as the majority, there are other built-in options. This talk revolves around the use of PowerShell and supporting aspects as a suitable option for an incident response solution for endpoints in your environment, to include shortfalls of the language.

The Configuration Management race has been heating up over the past few years, with a few contenders battling for your dollars: Puppet, Ansible, and DSC. But you’re moving to the Cloud, so do you even need a Configuration Manager? What’s the best solution for you? Come to this talk and find out!

As more and more organizations adopt a DevOps methodology, the importance of selecting a Configuration Management tool becomes paramount. Three CM tools that have separated themselves for the pack are Puppet, Ansible, and DSC. Each tool brings its own flavor of deployment, state maintenance, and idempotence. But which tool is right for your organization? As with most things, this depends largely on your individual environment and use case. This talk will give an overview of all three tools, and highlight the advantages and things to watch out for with each approach.


In this session, we will look at the many ways you can expose PowerShell scripts as web-based tools with PowerShell Universal. We’ll take a look at how to get started with Universal and how to set up your environment for developing against the platform. We’ll then dive into building REST APIs, running and scheduling scripts, and building dashboards. We’ll also touch on authentication and authorization features built into Universal.


Did you know that you can configure Azure Cloud Shell to be running inside a VNet so that we can use PowerShell Remoting to manage internal Virtual Machines? In this session, we will dive into this as well as other tools and techniques used to manage Azure in an effective manner using PowerShell.

In this session, we will look at leveraging a number of tools available for us for becoming an effective administrator in Azure. We`ll start by looking into Azure Cloud Shell and how to set up VNet integration to make it possible to reach services running inside VNets such as Private Endpoint-enabled PaaS-services, as well as Virtual Machines running both in Azure as well as on-premises. We will then look at different techniques for using PowerShell to manage Azure resources, such as various container images. We will close up by looking at how PowerShell can be used as the glue to fill gaps such as triggering automated PowerShell routines based on Azure Event Grid, for example, to create automated tags where Azure Policy is unable to meet the requirements. After this session, you should have a great overview of the various options available for managing Azure using PowerShell.


Nobody talks about certificates, though you find them everywhere: PowerShell script signing, WinRM session authentication, HTTPS. During this session, we’ll take a look inside a certificate, create our own, and put it to some practical use.

Starting with a quick review of Public Key Infrastructure (PKI), we’ll discuss the concept of trust and differentiate between common scenarios. What needs to happen when you sign the code? How does encryption work?

Walking step-by-step through the process of creating a self-signed certificate, we’ll discuss the properties of an X509Certificate2 object and understand its intended uses.

Because a certificate from a public Certification Authority (CA) has a much broader scope of use, we’ll see the ACME request process and use the resultant certificate for practical applications, including installation in on-premise IIS, an Azure App Service, using to secure a WinRM remoting session, and of course signing our PowerShell script!

Whether you are deploying Cloud infrastructure with ARM templates, Terraform modules, or something else entirely, you’re dealing with code, and code needs to be tested. Your infrastructure code should be no different. Let’s talk about some ways to test Terraform with Pester as an example.

When using Infrastructure as Code tools like Terraform to provision Cloud resources, you need to ask these questions:

   * How do I ensure the infrastructure I build is what I intended?

   * How do I protect against unintended behavior?

   * How do I continuously verify this?

In this talk, I will showcase how we at Stack Overflow continuously test our Terraform code with Pester to ensure that what we deploy in Azure adheres to our standards.


Need help with that cmdlet? Wish you could remember how you solved this problem last week? Join Damien Caro and Jason Helmick as they dive into configuring predictions that display historical and ML-based commands to accelerate your success. Learn new commands faster with the ML-based Azure PowerShell predictor, and see how Dynamic Help gets you the help you need just in time.

When developing tooling around PowerShell in a .NET language like C#, it's crucial to correctly understand and use the APIs that PowerShell provides for executing PowerShell commands and script from .NET. This talk explains how to do that, in particular by using the PowerShell API, what considerations you must make when doing so, and the pros and cons of various choices and techniques you might use in different scenarios.


Stop procrastinating and move from the deprecated PowerShell ISE to Visual Studio Code today! I’ll show you how to ease the transition.

You may be aware that the PowerShell Integrated Scripting Environment (ISE) is deprecated. Thus, if you haven’t moved your PowerShell development to Visual Studio Code yet, you should do so. In this session, Tim will show you everything you need to know to make VSCode behave as ISE does, and beyond.


There are a number of things the PowerShell community knows to speed up their scripts. These range from common sense to superstitious.

I have talked about optimizing PowerShell for Speed at a previous Summit, but with the work, that's been put into PowerShell 7 and beyond it’s time to revisit the topic.

Stop by this demo-heavy session to see if old truisms remain valid and if you even need to make any changes to your existing scripts to leave Windows PowerShell in the dust once you’re behind the wheel of its opensource big brother.

Who knows, PowerShell 7 may just be a performance-enhancing drug that should be banned from the Olympics.


Software can be very complex, we owe it to ourselves to make things simpler and seek out simple strategies. Simple is not the opposite of powerful, in fact, simple is powerful. Let's reframe your mindset to think about the power of simple and why it wins in the long run.


The Secret Management module from the Powershell team is in preview and provides a standard way of storing and retrieving secrets. In this talk I will show you how to build a Secret Management provider, and provide real-world examples using a powershell module interface, a REST API, and a command-line wrapper. If you have a favorite way to store Secrets and it can be automated in Powershell, you too can make a Vault Extension!



You’ve been working with containers in development for a while, benefiting from the ease and speed of the deployments. Now it’s time to extend your container-based data platform’s capabilities for your production scenarios.

In this session, we’ll look at how to build custom containers, enabling you to craft a container image for your production system’s needs. We’ll also dive deeper into operationalizing your container-based data platform and learn how to provision advanced disk topologies, seed larger databases, implement resource control and understand performance concepts.

By the end of this session, you will learn what it takes to build containers and make them production ready for your environment.

You need to give the help desk access to special tooling without giving them special creds or API keys. But how? Today more than ever we are concerned about embedding privileged info in our scripts. But what if you’ve gotta have that to get the job done? In this session, Ashley McGlone (@GoateePFE) will demonstrate a solution he built for the real world using pain old out-of-the-box JEA (Just Enough Administration) to deliver the goods without giving away the goods.

So you can write a function and put it into a module. Or maybe you have a killer production script. What will take it to the next level or make it easier to use? How about adding auto completers, custom formatting, or type extensions? Don’t know how? This is the session for you.

This session is aimed at experienced PowerShell scripters ready to go to the next level. You will learn how to add auto-completers to your commands which go beyond validation sets. You will learn the role dynamic parameters might play in your code and how to create them. You will learn how to add custom type and format extensions and why you want to use them. These are things that might make your module even more powerful, or make your daily PowerShell work easier. You’ll also see how easy it is to run your production scripts from anywhere!


In this session, we will share the best practices that you can apply when you are developing or maintaining PowerShell scripts managing Azure resources.

The team building the Az PowerShell module will give recommendations on how to best authenticate, deal with secrets, manage resources, handle errors, and more. We will also explain how to keep your code up to date and keep up with the pace of Azure services. Code is on the menu and we have saved time for questions. Brush up your knowledge of Azure PowerShell and prepare for a deep dive.


You’re not a regex noob. You know about quantifiers like ?, *, and +. You also know about tokens like \w, \s, and \d. It’s time, now, to take your regex skills to the next level with some advanced concepts like grouping, capturing, and look behind. Get ready to stand above your peers in a big way.

Regex intimidates people, and rightfully so. It’s complicated and isn’t always very readable for humans. It really takes some work to get your head around and truly understand regular expressions. This session is for people who know basic regex concepts and want to take their learning to the next level. Regex is like chess in that it’s easy to learn, but very hard to master. I’ll be teaching attendees some advanced moves to help them accelerate their learning and start doing some really cool things with regex. Anybody can write $number -match '\d', but not everyone can isolate the third octet out of an IP address.


After the acquisition of GitHub by Microsoft in 2018, we immediately asked ourselves: ""_where does this leave Azure DevOps and which tools do we use for a given situation""?_ After a little while, it became clear that Azure DevOps and GithHub would co-exist. A whole host of new features are still being added to GitHub, including GitHub Actions.

In this session, we look at the pros and cons of both products with a critical eye, through a number of technical demos. Finally, we will give a recommendation on which product is more suitable for your team!

We all might think we know the rules in PowerShell, but did you know you could break the game?

You will learn some handy and unusual tricks, including smart aliasing, anonymized recursion, flexible splatting, asynchronous programming, writing games in PowerShell, and more."

This session focuses on PowerShell Crescendo, a new Open-sourced PowerShell module to create a PowerShell module from other executables for a specific use case.

Anyone attending this session will be able to understand the use cases for where all this module can be used. The session covers the internals of PowerShell Crescendo module on how it generates a PowerShell module from a JSON configuration and the possibilities of extending the module as it is Open Sourced. Modules created by PowerShell Crescendo can be open-sourced, hence anyone who uses that module can extend it and make it more valuable and relevant for more users.

Do you want to access REST APIs using PowerShell with ease? With OpenAPI Generator, you can auto-generate a PowerShell module given an OpenAPI specification and then publish the module to PowerShell Gallery within minutes. In this talk, I'll walk you through the code generation process in 3 steps.

Using PowerShell to obtain data via REST(ful) APIs is not an uncommon task. Instead of using Invoke-RestMethod or Invoke-WebRequest to manually build the HTTP call, is there any other approach we can provide a better experience to PowerShell users? 

OpenAPI Generator, an open-source project used by IBM, Cisco, RedHat, and many more companies in production, offers an easy way to generate high-quality API clients in 30+ programming languages including PowerShell. All it needs is an OpenAPI specification describing the REST APIs and within minutes, it can generate a fully-functional PowerShell module with documentation, sample codes, and test templates.

In this talk, we will walk through an example of generating a PowerShell module and then publishing it to PowerShell Gallery in only steps. We will explain the fundamentals such as OpenAPI specification, OpenAPI Generator, and the core of the PowerShell module. Then we'll also touch on customizing the PowerShell clients to meet your unique requirements.


If you haven't mastered regex yet, I'm sure that it is one of the things on your bucket list. If not for its usefulness, for being able to proudly exclaim: 'I understand!' after carefully examining a character vomit. To fully grasp how effective regex can be, strap in for a full demo of examples.

Regex is used for string matching, that's cool, so what? PowerShell is object-oriented, who needs to worry about how strings are formatted?

Maybe you work in Active Directory, ever need to parse DNS or other identifiers? What about SQL and parsing connection strings? Or what if you are an application administrator and you need to parse some logs? Or heck, let's talk meta PowerShell regex and do some find and replacing of variables in a folder of scripts! Yes, there is plenty of regex to go around!

But! Even if there are lots of strings to regularly express, there are also times when regular expressions are not the best tool for the job. I want to make sure and cover a couple of examples of terrible things to regex and explain why (with some really gross regex).

Now, this isn't an introduction to regex (for that I would recommend checking out Mark Minasi's talk from 2018), this is a talk full of explained and practical regex examples designed to not only make your life as a PowerShell scripter easier but to also give you the motivation to learn more.

What happens when bad things happen to good scripts?  Code errors.  Run time errors.  Depending on how your scripts handle it - it can either become an end-user nightmare (Where did it terminate?  What was done?  What wasn't done?  Was there rollback? Or are we in an uncertain state?) or a pleasant end-user experience.  From your perspective was this a run time issue or did the user stumble upon a logic issue in your script?  Where did it blow up?  Can the error be fixed or if it is runtime trapped and handled?  Learn how to integrate error handling in your scripts to make your life easier and stop traumatizing end users with 'walls of red'!


Sometimes it's a pain to keep your scripts together and up to date with other team members. Well, fret no more, creating modules can help you keep your scripts up to date across many computers. Learn what the important parts of a module are, how to update them, and how I set up modules to be easy to work with.


Are you tired of being overwhelmed with cmdlet output or victim to Select-Object throwing away your data when you forgot to save it to a variable? In this presentation, I can teach you the lost art of object formatting! For more detailed information please see the course description.

When administrators use PowerShell to execute commands to retrieve information the data returned from the cmdlet's object output pipeline can be overwhelming. Overtime as business requirements changes so do the size of the workflows or scripts that are being executed to perform day-to-day operations. When this happens it is common for these scripts or workflows to become more complex, cumbersome, and inefficient. In the end, the time it takes administrators to filter through this data cost businesses lost revenue.

This might seem like a pretty bad and time-consuming situation, however, I am here to tell and show you there are ways to solve these issues. The answer is to customize your data output! Yes, I know that sounds complex, but it's not, once you understand some basic concepts about the PowerShell pipeline. I will do a deep dive on the pipeline, the logic behind it, and how you can manipulate the pipeline in ways you probably haven't seen before. 

The goal is of this presentation is to teach you how you grab the cmdlet information you care about and customize a data output that works for you. PowerShell has a few cool ways to display your information in (Table, List, Wide, or Custom) formats.

These are the topics that I will cover in this presentation:

1. How PowerhShell uses objects, sends them down the pipeline, how data can be persevered or throw away in the pipeline which affects formatting.

2. Speak about the importance of the PSMembersSet and DefaultDisplayPropertySet and how the PowerShell formatting engine uses them to present the object back to the console.

3. Walk through the PowerShell core types and formatting files and how to use them and create formatting templates.

4. How to create custom PowerShell objects from scratch and how to configure them for formatting.

5. How you can do this on the fly from a live interactive PowerShell console session and also in PowerShell modules.

By the time you are done, you will learn how to fill in the holes on a concept that many people don't fully understand and start using the pipeline to your benefit!

All project files will be posted on GitHub for download for you to use as ready to go examples.


In this talk, we will examine the process used in creating BluebirdPS, a PowerShell 7 module for the Twitter REST API. Topics will include learning the API, authentication, module structure, response, and error handling, and customizing the output.

BluebirdPS is a PowerShell 7 module that interacts with the Twitter REST API and is available in the PowerShell Gallery. This session will begin with a demonstration of a few of the module's commands, then we will see how the module was designed and implemented.

We will examine the core components of the module, the custom class used to generate the appropriate authentication header based on specific endpoint requirements, and the private functions that call the endpoints, format the results, and handle errors.

Next, we will discuss the public functions, those that use the API caller private functions, and those that are helpers that provide information to the user or manage configuration settings.


The dbatools project brings automation to the forefront of the SQL Server configuration, operations, and deployment tasks. In this session, we will look at how to install and configure multiple SQL Servers quickly and consistently using dbatools deployment tools. Once those systems are up and running we will look at how to configure and manage multiple systems using PowerShell automation techniques. By the end of this session, you will have the tools, techniques, and code to automatically and consistently deploy and configure SQL Server in your environment.

In this post, I will explain how to use the GitHub PowerShell module to manage your GitHub. 

We will see for instance how to: 

- Connect to your GitHub securely 

- Update your profile

- List your repositories

- Update content in a repo

- Create a repository and upload content 

- Migrate content from a GitHub to another one

- Migrate data from TechNet to GitHub

- Upload device logs to a private GitHub repo 

- Delete multiple repositories at once

- Get view, count of a repo

- Other things relative to your GitHub profile

Are you managing users in Active Directory or Microsoft 365 using PowerShell but would like an easier way for your Help Desk to execute those scripts? I'll go through some common user management scenarios and show you some simple ways to give your users a web interface using System Frontier. We'll cover what you need to get started, how to set up role-based access control (RBAC), and even how to integrate your new tools with other systems using the built-in REST API.


PowerShell SecretManagement is a module that securely manages secrets through a plug-able vault provider architecture. This talk explains how the SecretManagement module works, how to download and register extension vaults, and how to write an extension vault module. The Microsoft open-source SecretStore extension vault module will also be discussed as a cross-platform secure local storage vault solution.

The talk will go through the details of what happens when a pull request is opened on GitHub to when the change is released. We will be talking about all the processes and automation we developed along the 5 year journey to do a high quality PowerShell release and share the learnings.

Have you ever been removed from the ACL of a directory on a file server or been asked to restore permissions that somehow got screwed up? Pretty much unchanged since Windows NT4 there are still some mysteries to uncover around Windows Security. Managing permissions on NTFS volumes and the Windows Registry has gotten much easier thanks to PowerShell but some principles behind terms like security descriptor, DACL, SACL, inheritance are still quite unknown. This session covers the basics of how Windows controls access to many resources and how you can manage and report on these access lists with PowerShell. It also explains the term “privilege” (something that you see in the output of whoami.exe) and how you can make use of privileges to manage your resources much smoother in Windows PowerShell or PowerShell 6. You will learn how to access literally any file, regardless of how the ACL is defined, and how to manage, migrate, backup, and restore permissions with very short and simple PowerShell statements.

This session also talks about module design and when it is a good idea to switch from PowerShell to C#. The source code of the NTFSSecurity is examined

Platform-specific commands (Native) like Kubectl or netsh.exe work great in PowerShell, however, the unique syntax and output can be unfamiliar to a PowerShell user.  PowerShell Crescendo allows you to rapidly wrap a native command to be more like a cmdlet with consistent parameters, help and object-based output. Join James Truher and Jason Helmick to discuss how to use the benefits of Crescendo today and rapidly develop cmdlets for native commands.

PowerShellGet is a PowerShell module that provides commands to discover, install, update and publish PowerShell artifacts to/from remote and local repository stores. This talk and demo will look at V2 and V3 protocol support in PowerShellGet, the new NuGet APIs that are used, and some of the challenges implementing these APIs in order to provide wildcard support in V3. We will discuss how PowerShellGet 2.x.x and below is only able to interact with online repositories that use a NuGet v2 server protocol and how this was in part due to an architecture that was dependent on the PackageManagement module. We will look at how the architectural changes in PSGet v3 are compatible with both v2 and v3 protocols now, due to the removal of PackageManagement and extension of the NuGet client APIs. Lastly, we will discuss the differences in the V3 protocol that necessitated a different wildcard support implementation, how we use the NuGet CatalogReader APIs to provide this support, the challenges we faced, and our current solution. 

DesiredStateConfiguration is going cross-platform! This talk will cover the future direction of DSC, plans for PowerShell 7.2 timeframe, and differences between DSC for WindowsPowerShell and PowerShell 7.

Running Operations is not an easy job, especially these days. Ops teams have to ensure excellent user experiences, resolve incidents quickly and help developers stay productive. Yet at the same time, there is also the need to maintain systems security and keep downtime to a minimum - goals which many struggle with at scale.

While advances in cloud computing have helped address some of these challenges, many organizations find it difficult to leverage the cloud at scale because of bottlenecks that form around repetitive tasks, such as developers having to wait for provisioning infrastructure. Despite having access to abundant cloud resources, these speedbumps often make it difficult or impossible to achieve team objectives.

Join this talk to learn:

•How to safely delegate the management of your Azure deployment (to developers and other colleagues) with self-service operations.

•How to create powerful runbooks with guardrails that leverage existing scripting languages (including PowerShell), infrastructure, and tools to remove the human from the bottleneck that forms around repetitive tasks.

•Strategies for getting started

•And how to create an Easy Button to handle the repetitive tasks that are interrupting your flow of work.