The PowerShell Podcast

Andrew Pla pulls double conference duty in this episode, with stops on the San Diego waterfront at MMS Midway Edition and up north in Traverse City, Michigan for the MAEDS Fall Conference. First up is Matt Zaske, longtime MMS regular and self-described conference mascot (stickers and all), recorded with the occasional helicopter flyover from the USS Midway providing the soundtrack. Matt talks about his two sessions this year: a GitHub, CI/CD, and Actions deep dive aimed at sysadmins who aren’t developers, and a happy hour session on death planning and preserving your digital life. He makes the case that planning for the people you leave behind is as much about emotion as it is about tech, and that knowing what doesn’t matter (goodbye, home lab) is just as important as knowing what does (the Home Assistant setup your family depends on). Matt also shares how he’s using AI as a “trust but verify” sidekick, from writing ESP32 code he’d rather not fight with Python over, to having GitHub Copilot run code reviews on his own pull requests as a solo operator. 

Then Andrew heads to Michigan, which might just be the most PowerShell-loving corner of the IT world, to sit down with Dallas Schell. Dallas is a 27-year K-12 tech veteran who got his start the classic way, as the high schooler who got pulled out of class to fix the school network. He walks through how PowerShell acts as the duct tape of school IT, pulling student data out of the SIS, shaping it into custom objects, and pushing it into Active Directory, Google Workspace (via GAM), and whatever new product a grant drops on the district next. He also shares how he let AI loose on his old provisioning scripts, how his techs went from “that’s cheating” to “here’s what I did in Gemini today,” and why technology should be invisible when a teacher has 32 kids staring at them. 

Key Takeaways: 

Trust but verify. AI is a great way to lower the barrier to entry, whether that’s ESP32 code or old provisioning scripts, but if AI helped write your code, you should be its first reviewer. 

PowerShell’s object-based approach makes it the perfect glue. Take data from one system, build an object, and move it anywhere: Active Directory, Google Workspace, or that mystery product that came with a grant. 

Digital legacy planning matters for sysadmins. Think about who will actually be handling your stuff, what they can realistically execute in an emotional moment, and how your projects and home infrastructure live on after you. 

Guest Bios: 

Matt Zaske is a repeat MMS speaker and longtime community member, known for his sessions on task sequences, 3D printing, and Home Assistant, as well as his humor, storytelling, and the stickers and 3D prints he hands out to help attendees break the ice. 

Dallas Schell has worked in Michigan K-12 technology for 27 years, splitting his career between 13 years at the county level and 13 years at a local district. Like many school tech directors, he started as a student who got drafted to help with the school network. Today he focuses on automating student provisioning and data integration with PowerShell, mentoring his techs, and making technology transparent for teachers. 

Resource Links: 

MMS Midway Edition schedule: https://mmsmidway.sched.com 
Matt Zaske’s blog: https://www.mzonline.com 
Matt Zaske on Sessionize: https://sessionize.com/zaskem 
MAEDS (Michigan Association for Educational Data Systems): https://maeds.org 
Michigan Data Hub (MiDataHub): https://www.midatahub.org 
GAM7 for Google Workspace administration: https://github.com/GAM-team/GAM 
PDQ Connect PowerShell Scanner: https://www.pdq.com/blog/the-powershell-scanner-has-arrived-in-pdq-connect/ 
PDQ Discord: https://discord.gg/PDQ 
Connect with Andrew Pla: https://andrewpla.tech/links 
The PowerShell Podcast: https://www.pdq.com/resources/the-powershell-podcast/

Jim Tyler is back for his third visit to the PowerShell Podcast, and he showed up with a full bag of new projects. Andrew and Jim dig into the PowerShell Engineer Standard, Jim's effort to get AI tools writing PowerShell the way a seasoned engineer would. What started as a Chrome extension idea for teachers turned into an AGENTS.md and CLAUDE.md standard, browser extensions, a VS Code extension that loops in PSScriptAnalyzer, and even a lightweight local model on Hugging Face so you can generate quality PowerShell without burning tokens.

From there the conversation gets real about security in an agentic world. Jim talks about why local models matter for K-12 data privacy, why open weight coding models with no guardrails keep him up at night, and why small misconfigurations are now legitimate attack paths when an agent can probe your environment in seconds. He also shares how he has used PowerShell and AI to build audit tooling for Google Workspace that simply didn't exist before.
The episode closes on the heart stuff. Jim walks through Model Communicator, the free AAC app he built with speech-language pathologist Kara Cotter to give nonverbal kids a voice without the $300 price tag or the months-long insurance wait. Plus a shout out to Jorge Suarez and endpointjobs.dev, the evolution of PowerShell.News and its new Repo Roundup, Jim's rebranded K-12 Engineer YouTube channel, and his "imposter to presenter" message that everyone has something worth sharing.

Key Takeaways:

Good AI output starts with good guardrails. The PowerShell Engineer Standard bakes in best practices like advanced functions, CmdletBinding, splatting, and version awareness up front, so you aren't fixing the same mistakes after the fact.
Agents have changed the threat model. Misconfigurations that used to feel obscure are now real attack paths, which makes zero trust, process controls, and regular audits more important than ever.
AI lowers the barrier to building meaningful tools, but expertise still matters. Model Communicator works because a speech-language pathologist hand-touched every board, and Jim still reads and understands the PowerShell his tools produce.

Guest Bio:
Jim Tyler is the Director of Technology at Niles Community Schools in Michigan, a Microsoft MVP, and the creator of PowerShell.News and PowerShellEngineer.com. He is the author of PowerShell for Systems Engineers and an elected school board member. Alongside speech-language pathologist Kara Cotter, Jim co-created Model Communicator, a free AAC app for nonverbal learners. He shares PowerShell, security, and AAC content on his YouTube channel, K-12 Engineer, and is a regular speaker in the Michigan K-12 tech community, where he encourages first-timers to go from imposter to presenter.

Resource Links:

PowerShell Engineer: powershellengineer.com

PowerShell Engineer Firefox extension: addons.mozilla.org/en-US/firefox/addon/powershell-engineer

PSEng model on Hugging Face: huggingface.co/jimtyler/pseng-14b-preview

PowerShell News: powershell.news

Model Communicator: modelcommunicator.com

Endpoint Jobs: endpointjobs.dev

PSScriptAnalyzer: github.com/PowerShell/PSScriptAnalyzer

CISA ScubaGoggles: github.com/cisagov/ScubaGoggles

Locksmith: github.com/jakehildreth/Locksmith

Maester: maester.dev

dbatools: dbatools.io

PowerShell is fun (Harm Veenstra): powershellisfun.com

ThreatLocker: threatlocker.com

PDQ Discord: discord.gg/pdq

The PowerShell Podcast on YouTube: https://youtu.be/gMUhzfLVchM

It's the Halloween episode, and Jake Hildreth is back to raise the dead. Fresh off Wild West Hackin' Fest in Deadwood, South Dakota (a town of 1,100 people that welcomes 1,200 hackers, a mechanical bull, and a round of Hacker Feud), Jake walks Andrew through his talk. The talk idea is simple and kind of brilliant: one tool to build a vulnerable AD CS lab, one tool to attack it, and one tool to defend and fix it. He also shares the very real story of ripping the auto-pwn pieces out of ESCalator four days before the talk and finishing his demos 45 minutes before showtime.

Then things get spooky. Jake explains "zombie certificates," a persistence risk he uncovered while feeding RFCs and open spec docs into an LLM-built wiki and hunting for mismatches. A single registry value meant for testing and troubleshooting flips certificate revocation checking from fail closed to fail open. Pair that with the CA's disable extension list, strip the CRL address off a certificate, and you've got a cert you can revoke all day long that still lets an attacker walk right back in. The good news is the fix is straightforward hygiene. Along the way, Jake and Andrew talk about the full circle moment of thanking the person who got Jake into AD security, why sharing what you learned yesterday matters, and how a little mentoring can change someone's whole career path.

Key Takeaways:

Testing settings have a way of becoming permanent. A registry value meant for troubleshooting smart card logon can quietly turn certificate revocation into a fail open situation, so audit your domain controllers for it and only use it when you're actively testing.

Certificates that can't be checked can't be killed. Keep the CA's disable extension list clean and make sure revocation info stays on your certificates, or revoking a compromised cert may do absolutely nothing.

Learn it, then teach it. Jake turned years of AD CS work into tools, talks, workshops, and courses, and the people he's helped are now paying it forward with content of their own.

Guest Bio:
Jake Hildreth is a Principal Security Consultant at Semperis, a Microsoft MVP in both PowerShell and Identity/Access, and a recovering sysadmin with 25 years of IT under his belt. He's probably best known for building Locksmith, the open-source AD CS auditing and remediation tool, but he's also the creator of Stepper, Deck, BlueTuxedo, and PowerPUG! — a suite of tools designed to make identity security a little less painful for the admins who live in it. When he's not untangling Kerberos or chasing down ADCS misconfigurations, and can usually be found saying ridiculous things in the PDQ Discord's #off-topic channel.

Resource Links:

Battling Zombie Certificates: The Persistent Risk Lurking in AD CS (Semperis blog): https://www.semperis.com/blog/how-to-battle-zombie-certificates-persistent-ad-cs-risk/

Jake Hildreth's Website: https://jakehildreth.com

Jake's Blog: https://blog.dotdot.horse

Jake's GitHub: https://github.com/jakehildreth

ADCSGoat (Deliberately Vulnerable AD CS Lab): https://github.com/jakehildreth/ADCSGoat

ESCalator (AD CS Issue Combination Finder): https://github.com/jakehildreth/ESCalator

Locksmith (AD CS Auditing and Remediation): https://github.com/jakehildreth/Locksmith

Wild West Hackin' Fest: https://wildwesthackinfest.com

Hybrid Identity Protection Conference (HIP Conf): https://www.hipconf.com

CodeMash: https://www.codemash.org

PDQ Discord: https://discord.gg/pdq

Andrew's Links: https://andrewpla.tech/links

The PowerShell Podcast on YouTube: https://youtu.be/ik4hlES4Uwc

Fresh off a PowerShell Wednesday session on Windows PowerShell versus PowerShell 7, Andrew Pla sits down with Ryan Yates, a longtime pillar of the UK PowerShell community and member of three PowerShell Working Groups (Cmdlets, Engine, and Interactive UX). Ryan pulls back the curtain on what working group members actually do, from triaging issues and reviewing PRs to deciding how bugs and enhancements should be implemented before the community picks up the work.
The conversation rewinds to Ryan's early days as an IT apprentice at Barclays, where supporting SharePoint without a Visual Studio license led him straight to PowerShell and a lifelong love of breaking things to learn how they work. Ryan also shares his take on PowerShellGet and PackageManagement headaches, why PSResourceGet and DSC v3 point to a better future, how AI's cost barrier affects everyday PowerShell users, and his dream of turning old devices into a local AI compute farm.
Things wrap up with a rapid-fire lightning round covering underrated cmdlets, favorite automatic variables, the most rewritten code block in PowerShell history, and a heartfelt call for more community eyes on the PowerShell repository.

Key Takeaways:

The PowerShell Working Groups triage issues and decide how bugs and enhancements should be handled, which opens the door for community members to step in and contribute the actual code.

PSResourceGet (Install-PSResource and Find-PSResource) is the path forward for module management, and cross-platform software installation is shifting toward DSC v3 rather than PowerShell itself.

Anyone can contribute. Start a discussion or open an issue in the PowerShell repository, and the team can convert between the two as needed. Everyone made their first contribution at some point.

Guest Bio:
Ryan Yates is a UK-based PowerShell community member who has been a driving force behind the UK and international PowerShell communities for over a decade. A former seven-time Microsoft MVP for PowerShell, Ryan currently serves on the PowerShell Cmdlets and Modules, Engine, and Interactive UX Working Groups, where he is in the PowerShell repository triaging, testing, and contributing. He began his career as an IT apprentice at Barclays supporting SharePoint, which led him to PowerShell, and he went on to help organize UK PowerShell user groups and PSDay UK. Ryan also helped keep the PowerScripting Podcast running in its later years. You can find him most days in the PowerShell Discord as pwshdoodUK.

Resource Links:

Ryan on GitHub: https://github.com/kilasuit

Sponsor Ryan on GitHub: https://github.com/sponsors/kilasuit

Ryan's Blog: https://blog.kilasuit.org/

Ryan on LinkedIn: https://uk.linkedin.com/in/ryanyates90

PowerShell Repository: https://github.com/PowerShell/PowerShell

PowerShell Working Group Definitions: https://github.com/PowerShell/PowerShell/blob/master/docs/community/working-group-definitions.md

PSResourceGet: https://github.com/PowerShell/PSResourceGet

DSC v3: https://github.com/PowerShell/DSC

ConsoleGuiTools (Out-ConsoleGridView): https://github.com/PowerShell/ConsoleGuiTools

Microsoft.WinGet.Client Module: https://www.powershellgallery.com/packages/Microsoft.WinGet.Client

PowerShell Discord: https://discord.com/invite/powershell

PDQ Discord: https://discord.gg/pdq

The PowerShell Podcast Hub: https://pdq.com/the-powershell-podcast

The PowerShell Podcast on YouTube: https://youtu.be/r5IYrhIEH4Y

Andrew sits down with longtime PowerShell legend James Brundage to recap what he calls his "summer of fun," a stretch of side projects that prove PowerShell can go way further than most of us ever thought to push it. James kicks things off with Wave, a module for creating and manipulating real .wav files in the object pipeline. Once you see audio as a sine wave and some math, you can generate notes, play music, and even draw animated SVG waves straight from PowerShell.
From there, the tour keeps rolling. MarkX turns Markdown into queryable XML so you can pull out code blocks or turn Markdown tables into typed data tables. James also shares how a vibe coded Wolfenstein 3D style clone in PowerShell (that got pulled from the internet after some tough feedback) sent him down the audio rabbit hole, and how he's collaborating with Bruce Payette on getting Braid to play nicely with PowerShell.

Then it gets visual. James walks through his Matrix module, which brings the transformation matrices already baked into .NET over to PowerShell and CSS, and shows off a hallway of fake 3D depth built entirely with PowerShell generated SVG. He explains the simple trick behind PowerShell static sites (a .html.ps1 script that spits out HTML, plus a ToString or HTML property on your objects) and shares Fun, a tiny web server where any function named with a leading slash becomes a web page. The episode wraps with a promise of a Part 2, because there is clearly way more to cover.

Key Takeaways:

PowerShell can do a lot more than most of us assume. Audio waveforms, Markdown as queryable data, matrix transforms, and fake 3D graphics are all fair game once you understand the small piece of math or tech underneath.

Static websites in PowerShell have been possible since version 1. Redirect output from a .html.ps1 script to a file, and add a ToString or HTML property to your objects so they render nicely on the web instead of dumping text in a terminal.

With the Fun module, naming a function with a leading slash turns it into a route on a local PowerShell web server, which makes web experiments quick and low stakes.

Guest Bio:
James Brundage is a former Microsoft engineer and one of the most prolific PowerShell developers around, known through his company Start-Automating and the handle MrPowerShell. He is the author of a long list of open source modules, including RoughDraft for multimedia work with FFMpeg, and he founded the PoshWeb GitHub organization to bring together open source PowerShell web development projects. James is currently heads down on creative projects around PowerShell web development, audio, and graphics.

Resource Links:
PoshWeb GitHub organization (open to new contributors) https://github.com/PoshWeb
Wave (work with wave files in PowerShell) https://github.com/PoshWeb/Wave
MarkX (Markdown, XML, and PowerShell) https://github.com/PoshWeb/MarkX
Matrix (matrix transforms with PowerShell, CSS compatible) https://github.com/PoshWeb/Matrix
https://www.powershellgallery.com/packages/Matrix
Fun (a fun functional PowerShell server) https://github.com/PoshWeb/Fun
James Brundage on GitHub https://github.com/StartAutomating
James Brundage's website https://MrPowerShell.com
Previous PowerShell Podcast episode with Bruce Payette on PowerShell and Braid https://pdq.com/resources/the-powershell-podcast/ep-82-exploring-powershell-braid-and-beyond-with-bruce-payette
The PowerShell Podcast on YouTube: https://youtu.be/WLEo6EjZqFM