The PowerShell Podcast

By PDQ.comTechnology

The PowerShell Podcast episodes

November 02Teaching AI to Write PowerShell the Right Way with Jim Tyler
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
45 min
October 26Night of the Living Certificates with Jake Hildreth
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
41 min
October 19Inside the PowerShell Working Groups with Ryan Yates
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
35 min
October 12The PowerShell Summer of Fun With James Brundage
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
40 min
October 05From Flow State to Agent State with Adam Driscoll
Adam Driscoll, creator of PowerShell Universal, returns to the show for a deep dive into how AI has reshaped his day to day work. Since selling PSU to Devolutions last October, Adam has gone from writing thousands of lines of code himself to running a fleet of coding agents through GitHub Copilot, working across the PSU codebase, documentation, and Jira tickets. He and Andrew talk candidly about the personal side of that shift, the strange mix of mourning your old flow state while also getting more done than ever. From there the conversation turns practical, covering how Adam builds guardrails around agents using PowerShell modules and MCP servers, why planning in smaller steps beats one shotting a huge feature, and why Pester testing has quietly become non negotiable. They wrap with a PowerShell Universal 2026.3 update, including a redesigned admin console, new AI chat and MCP guardrail features, and Devolutions Agent support for running PSU jobs, plus a fun detour into Adam's side projects: a fully managed SQLite engine called Ahtola and an accidental 20,000 line Unity game.

Key Takeaways:
Treat your AI coding agent like a junior developer. It needs the "why" behind a task, not just the "what," or it will fill in the gaps with assumptions you don't want.
Guardrails matter more as agents get more capable. Adam constrains what his agents can touch by routing them through well defined PowerShell functions and MCP tools rather than giving them free rein, and tool approval settings let IT admins do the same in more sensitive environments.
Break big builds into small, reviewable steps instead of writing a massive plan and letting the agent run wild with it. Smaller steps mean you can actually review what changed at each stage.
Guest Bio:
Adam Driscoll is the creator of PowerShell Universal and joined Devolutions in October 2025, where he now leads its continued development. He's a longtime fixture in the PowerShell community, known for his tooling work and prolific output.

Resource Links:
https://ironmansoftware.com/
https://devolutions.net/
https://bsky.app/profile/adamrdriscoll.com
https://discord.gg/PDQ
The PowerShell Podcast on YouTube: https://youtu.be/u5zTzgEhWT8
51 min
September 28From Burnout to Buy In, Justin Grote on Building in the Age of AI Agents
Justin Grote (posh.guru) rejoins the PowerShell Podcast a year after his last appearance to talk about how fast the agentic AI world has moved since then. He walks through his experiments with the agent host protocol, running coding agents in isolated dev boxes and spot VMs so a stray command can only trash a container instead of his laptop. He and Andrew dig into what a "harness" actually is, how tools like these steer raw model output into something useful, and why that shift pushed Justin into a real existential dip this past summer, wondering what the point of hand building modules is when an agent can spin one up on demand. He works through how he came out the other side (doing it for the love of the game and the community), then gets into the practical stuff: a from-scratch C# rewrite of ModuleFast that cut Az module install time from seven seconds to three, the ExcelFast beta for slinging PowerShell objects in and out of Excel, and how he's tuning prompts using VS Code's new debug view and token caching. They also cover the rise of agent plugins (bundled skills plus MCP), his favorite lightweight plugin Ponytail, and Justin's read on where PowerShell fits once AI can talk to APIs directly. The conversation closes on advice for people getting into PowerShell right now and where to find Justin online.

Key Takeaways:
Agentic coding is moving fast enough that "harnesses" (the coordination layer around an LLM, like GitHub Copilot or Claude Code CLI) matter as much as the underlying model, and running agents in isolated dev boxes or spot VMs lets you hand over real autonomy without real risk.
Feeling threatened by AI generating modules on the fly is common right now. Justin's answer was to keep building for the love of the craft and the community rather than chasing relevance.
PowerShell's role is shifting from "the way you talk to a computer" toward a rapid prototyping and troubleshooting tool that both humans and AI agents reach for, especially anywhere a GUI or a full compiled language is overkill.
Guest Bio:
Justin Grote is a PowerShell MVP and the author of ModuleFast and ExcelFast, along with other tools in the PowerShell ecosystem like PoshNmap and several SecretManagement extensions. He works for a managed services provider and has been a fixture of the PowerShell community for years, known online as posh.guru.

Resource Links:
Justin Grote on GitHub https://github.com/JustinGrote
Justin Grote on Bluesky (posh.guru) https://bsky.app/profile/posh.guru
ModuleFast https://github.com/JustinGrote/ModuleFast
ExcelFast https://github.com/JustinGrote/ExcelFast
Ponytail (the agent plugin Justin mentioned) https://github.com/DietrichGebert/ponytail
PowerShell Discord https://discord.com/invite/powershell
The PowerShell Podcast on YouTube: https://youtu.be/MsgZoIKYnY0
59 min
September 21Living Off the Land With Spencer Alessi
Andrew welcomes back pen tester and AD security enthusiast Spencer Alessi (Tech Spence) fresh off DEF CON for a wide ranging chat on where PowerShell still fits into offensive security, how AI is changing his workflow, and what makes an environment genuinely painful to attack. Spencer talks through why PowerShell remains a favorite for both attackers and defenders, how he uses LLMs to speed up one off scripting tasks (and where they still fall short), and how he leans on AI tools to obfuscate offensive tooling during engagements. The conversation shifts into real world stories from the field, including a memorable case of exposed domain user hashes sitting on an overly permissive share, before wrapping up with the three controls Spencer sees make the biggest difference for defenders: application control, content filtering, and network segmentation.

KEY TAKEAWAYS:
PowerShell is still a top tool for both attackers and defenders because it is fast, flexible, and built into every Windows box, which is exactly why locking it down matters.
AI is great for offloading quick one off scripting tasks, but it often assumes intent incorrectly and can produce messy code, so manual review and hand written scripting still matter.
Application control, outbound content filtering, and network segmentation are the three controls Spencer sees make attackers' lives noticeably harder.
GUEST BIO:
Former Sysadmin, now Pentester @SecurIT360 | Microsoft MVP | Helping IT teams make their environment harder to attack | Social Media content & podcast @CyberThreatPOV

RESOURCE LINKS:
Spencer's website and newsletter: https://spenceralessi.com
Spencer's link hub: https://links.spenceralessi.com
Andrew's link hub: https://andrewpla.tech/links
SecurIT360: https://securit360.com
The Cyber Threat Perspective podcast: https://offsec.blog
PowerSploit (offensive PowerShell framework): https://github.com/PowerShellMafia/PowerSploit
Locksmith (AD CS misconfiguration finder, Spencer is a contributor): https://github.com/TrimarcJake/Locksmith
ScriptSentry (Spencer's logon script scanner): https://github.com/techspence/ScriptSentry
PDQ Discord community (PowerShell scripting channel): https://discord.gg/pdq
PowerShell Wednesdays (weekly livestream): https://www.youtube.com/@PDQ
The PowerShell Podcast on YouTube: https://youtu.be/DDbBZqEJkSI
46 min
September 14Microsoft 365 DSC Without the 100 Page Setup Guide with Constantin Hager
Andrew welcomes back Constantin Hager, a senior systems engineer, PowerShell User Group organizer, and brand new Microsoft MVP. They open by revisiting Constantin's infamous "size of a finger" intro from his first appearance, then dig into his talks at PSConfEU this year on dev containers with GitHub Codespaces and on Maester, the testing framework for M365 and on-prem AD. A quick detour into the GitHub vs. GitLab vs. Codeberg debate leads into the main event: a deep breakdown of Microsoft365DSC, what it actually does, how it treats M365 tenant settings like Intune, Entra, and Exchange as idempotent, drift-monitored code, and how the M365DSC Workshop wraps the notoriously painful setup process into a lab folder anyone can run. They cover the workshop's multi-tenant design, its DSC Community roots, and the honest limitations, like settings that still aren't exposed through public APIs. Constantin also shares his organic path to becoming an MVP, updates on his user group's shift to English-language talks, and a heads up on an upcoming blog series diving deeper into M365DSC. They close with news on the free PSConfEU MiniCon, happening October 13th with the CFP open until September 25th.
Key Takeaways:
Microsoft365DSC turns M365 tenant configuration into idempotent, drift-monitored code, and the M365DSC Workshop exists specifically to make the notoriously painful setup process approachable through a ready-to-run lab folder instead of a hundred-page whitepaper.
Not everything in M365 is automatable yet. Settings without a public API (some Copilot controls, for example) still require manual portal fixes or an interactive token, so full automation has real gaps today.
Constantin's MVP award grew out of years of showing up, organizing his user group, speaking at conferences, and opening GitHub issues, not out of being the loudest voice in the room.
Guest Bio:
Constantin Hager is a senior systems engineer based in Germany, organizer of the PowerShell User Group Inn-Salzach, and a newly awarded Microsoft MVP. A returning guest of the podcast, he's known for his enthusiasm around dev containers, PSFramework, and now Microsoft365DSC.

Resource Links:
Constantin Hager on LinkedIn https://www.linkedin.com/in/constantin-hager/
Constantin's blog, The IT Guide https://the-itguide.de
Andrew's blog: https://andrewpla.tech
PowerShell User Group Inn-Salzach (Meetup) https://www.meetup.com/de-DE/powershell-usergroup-inn-salzach/
Maester (M365 and Entra security testing framework) https://maester.dev/
Microsoft365DSC official site https://microsoft365dsc.com
Microsoft365DSC on GitHub https://github.com/microsoft/Microsoft365DSC
M365DSC whitepaper and CI/CD pipeline scripts https://github.com/ykuijs/M365DSC_CICD
DSC Community https://dsccommunity.org
PSConfEU https://psconf.eu
PSConfEU MiniCon Call for Papers (Sessionize) https://sessionize.com/psconfeu-minicon/
PDQ Discord https://discord.gg/PDQ
The PowerShell Podcast on YouTube: https://youtu.be/Vy4kaayGT2M
41 min
September 07 Learn PowerShell by Solving Real Problems
David McFall joins Andrew Pla to talk about practical PowerShell, mentorship, automation, and why you do not need to be a PowerShell expert to get serious value from it. David shares how he uses PowerShell across Active Directory, Entra, Microsoft 365, Microsoft Graph, and PDQ, including real-world examples like device posture reporting, identifying hardware gaps, and automating project management. They also dig into learning with AI, knowing when a simple script is enough, the importance of testing before production, and why helping the people around you grow can make everyone’s job easier.
Key Takeaways:
· PowerShell does not have to be complicated to be useful. David approaches PowerShell as a working sysadmin who wants to automate repetitive tasks, reuse existing tools, and solve real problems rather than build everything from scratch.
· AI can accelerate learning, but it should not replace understanding. David uses AI to better understand PowerShell concepts and Microsoft Graph, while emphasizing the importance of reviewing, testing, and understanding scripts before putting them into production.
· Sharing knowledge makes the whole team stronger. David views himself as a mentor rather than simply a manager. Helping junior team members develop their skills gives them more opportunities while also creating a team that can share responsibility instead of relying on one person who knows everything.
Guest Bio:
David McFall is an IT infrastructure and operations leader with experience across enterprise cloud platforms, cybersecurity, system administration, Microsoft Defender, Azure, incident response, and automation. Based in Metro Detroit, David combines hands-on technical work with a strong focus on mentoring IT professionals and sharing what he has learned throughout his career.
Resource links:
ImportExcel (create Excel reports without Excel installed) https://github.com/dfinke/ImportExcel
PSWriteHTML (build interactive HTML reports from PowerShell) https://github.com/EvotecIT/PSWriteHTML
BurntToast (Windows toast notifications from PowerShell) https://github.com/Windos/BurntToast
Maester (automated Microsoft 365 security posture testing) https://maester.dev
The PowerShell Podcast on YouTube: https://youtu.be/36VN6K-oE8w
42 min
August 31How to Test Microsoft Graph Without a Live Tenant with Morten Mynster
Andrew welcomes Morten Mynster back to the PowerShell Podcast to dig into the projects he’s been building around Microsoft Graph, Entra, least privilege, and authentication. Morten walks through Least Privileged Entra, a module that uses activity logs to identify users who may have more permissions than they actually need, and MS Graph Proxy, which lets developers work with mocked Microsoft Graph data locally without connecting to a live tenant. They also get into managed identities, the rougher corners of Microsoft 365 APIs, testing Graph-based projects in CI/CD pipelines, and how contributing to open source can solve real problems while creating unexpected career opportunities.

Key Takeaways:
· Least privilege is easier when you can see what people actually use. Morten’s Least Privileged Entra module compares assigned Entra roles with activity data to identify permissions that may be unnecessary and suggest more limited alternatives. The goal is to give admins something actionable rather than simply reporting that a configuration passed or failed.
· You don’t always need a live Microsoft 365 tenant to develop against Microsoft Graph. MS Graph Proxy intercepts Graph requests and responds with mocked data, allowing developers to test scripts and modules locally, offline, or inside CI/CD pipelines. It can also identify the minimum Graph permissions associated with the endpoints an application uses.
· Sharing your work can have benefits far beyond the project itself. Morten credits his Least Privileged MS Graph project with helping him land his current job. His approach is simple: solve a real problem, share the solution, contribute where you can, and let other people build on what you’ve learned.

Guest Bio:
Morten Mynster is an IT professional and open source contributor focused on Microsoft Entra, Microsoft Graph, security, and least privilege. His projects include LeastPrivilegedMSGraph, LeastPrivilegedEntra, and MSGraphProxy, and he regularly contributes to community projects and discussions around Microsoft 365 security and PowerShell.

Resource Links:
https://github.com/Mynster9361/Least_Privileged_MSGraph
https://github.com/Mynster9361/LeastPrivilegedEntra
https://github.com/Mynster9361/msgraphProxy
https://github.com/FriedrichWeinmann/EntraAuth
The PowerShell Podcast on YouTube: https://youtu.be/cB_QE1HvAyI
25 min

About The PowerShell Podcast

From the publisher's feed

The PowerShell Podcast is a weekly show about building your career with PowerShell. Each episode features the tips, tech, and modules that make PowerShell the premier automation and scripting tool for…