PSConfEU 2026

I attended my third PSConfEU event, this time it was in Wiesbaden (Germany). In this long blog post, I will recap the week, the sessions, the event, the people I met, and everything else surrounding it.

What is PSConfEU?

“The PowerShell Conference Europe is a community-driven event established back in 2016, and Europe’s largest PowerShell conference.
With about 300 automation experts from 35 countries meeting 45 world-class speakers, and some members of Microsoft’s Engineering teams, the annual event is an opportunity for EMEA IT Professionals and developers to connect, learn, and share on PowerShell and automation topics, bringing home new insights.”

Source: https://www.linkedin.com/showcase/psconfeu/about/

The day before

This year I took the ICE train instead of the car or train. Started from Amsterdam to Wiesbaden, traveled together with Gijs Reijn (Fellow PowerShell MVP). Met up with Ravi at the train station in Wiesbaden, checked into our separate hotels.

Day 1 – Monday, June 1st

Opening ceremony

The opening started with Rob, Barbara, and Gael in their typical way 😀 And after a part of the 2016 introduction, they came up to the stage in their flashy outfits 🙂

It’s the celebration of 10 years of PSConfEu, from Hannover to Wiesbaden. And it’s like they said, you’re with your people now! They explained the rules, where you can find more information, etc. But also a flashback to Project Monad (2001), the Monad Manifesto, and the different versions of PowerShell.

After a lot more of great slides and humor, Gael started a Chocolately demo with AI to update his Putty on his local system in Yolo mode 😉 AI is just another tool. not the master and you should tame it…Gael also touched on the MCP features, which are now more widely available. He then demoed PowerShell Universal and AI, a nice way to thank our sponsors and showcase new technology alongside their products.

Barbara demoed the newer CoPilot features, including writing Pester tests, and Rob talked about SQL Server 2025 and its automation endpoint. He demoed the Contoso Coffee company and AI-powered Stored Procedures.

And… PowerShell will be included in Windows Server vNext 🙂 (No more PowerShell v2.0 in Windows Server, like announced earlier)

Navigating the AI Revolution – Jeffrey Snover

After the first round of coffee, Jeffrey started his session about the AI Revolution. Great slides, jokes, and insights into the growth of AI. Don’t become a dinosaur 🙂

He discussed the growth needed to make AI into something good. He also talked about the job destruction or job growth that will follow AI growth. Also, how vibe coding works, about giving up control over how things look, error tolerance, etc.

Great insights, and enjoyably presented by the PowerShell inventor.

State of the Shell – Steven Buchner

Steven kicked off the State of the Shell, reflecting on the last five years of PSConfEU and the current state of PowerShell. But also about the history of PowerShell, the structure of it, and how it makes managing Windows easier. The IT world is messy; tools that much match, AI-assisted work, and CLI-first adaptation are the themes now.

The sacred vow still holds: If people invest time in learning PowerShell, the team will strive to keep that skill set possible. With the release of PowerShell v7.6, quality-first releases were their main goal, removing MSI as a legacy. This time, no demos, but more insight into the development process and the PowerShell v7 release inbox in Windows Server vNext (Preinstalled, just like it was with PowerShell v5). It will be included in the next Windows Insider builds as well.

Steven then talked about imperative scripts, declarative config, and intent-based tooling.

The responsibility is still human, AI handles the busywork, tests and validates, and speeds up coding. People are still doing the hard work, finding issues fast, and keeping watch. The other topic was API vs CLI and why it matters. He talked about the Team’s effort in creating AI Shell, lessons learned from that, and future plans for creating tools for agents.

AI generates scripts, tests, and docs, but you review and validate the code. Capability evolves, but responsibility endures.

It Works On My Machine… So We Will Ship Your Machine. Devcontainers! – Justin Grote

After lunch, I joined Justin’s session on DevContainers (One of my favorite subjects 🙂 )

After explaining the DevContainer architecture and its integration with VSCode, he showed the different ways to run them. He highlighted Docker, Podman, GitHub Codespaces, CodeSandbox, and the difference between daemon-based versus daemonless containers.

He started demoing the different options and highlighted resources such as https://containers.dev, https://hub.docker.com, and https://mcr.microsoft.com. Even though the Wi-Fi speed wasn’t great (and not using the wired connection ;-), he walked us through the process of starting and using Devcontainers. Q&A questions were good, too!

Securing PowerShell from the Ground Up – Andrew Pla, Jake Hildreth

After having some screen issues, the session finally started with those screen issues still present 🙂

After the introduction of Andrew and Jake, the agenda for the session:

The highlighted the no logs, no trail issue. For example, 49% of ransomware involved PowerShell in 2023. This makes securing PowerShell so important. The goal is not to disable PowerShell, but secure it. Important takeaways are logging, constrained language mode, and removing PowerShell v2.0.

Script Block Logging was then demoed, obfuscated Base64 encoded eventlog entries were shown, and an Invoke-Obfuscation walkthrough was done.

Constrained Language Mode was explained, how you’re not allowed to call .NET methods, can’t dot-source files, etc.

Scan the QR code below to use the SecurityPosturePS script that Andrew wrote to easily switch between constrained mode on and off.

And don’t forget: PowerShell v2.0 has been removed from Windows, but is still an attack vector for machines that still have it installed or enabled.

Argument Completers, Dynamic parameters, and more: Building better PowerShell functions – Ben Reader

After a small break, with ice-cream!, I joined Ben Reader’s session. “Guide your users to success with controlled inputs and bomb-proof input validation” is the topic 🙂 The agenda was:

He showed how you can use validation in a Function to prevent incorrect values, such as lowercase vs. uppercase. Using ValidateSet in combination with IgnoreCase = $False, he worked around naming issues with Parameter values. But using ValidateRanges, ValidateCount, and ValidatePattern to prevent people from using values above the allowed range is also very powerful. He also showed how to use classes in the Param block to validate conditions, such as whether a path exists.

But, as things usually go, the requirements change, and the organization wants to adapt it to other databases and scenarios. Ben showed how to create a configuration folder to separate configuration from the script, making things more flexible. And also how Public and Private folders work, storing helper Functions in there, etc.

The ArgumentCompleter functionality is very nice, making it more flexible and adapting to the options needed for a specific case. (This is not the same as ValidateSet )

Ask the Hivemind

This is the part of PSConfEU where you can ask questions about topics at specific parts of the main conference room; you can either answer or ask questions. Other topics were the Shorten the Code contest, the PSConfEU Module, the Community Dinner, etc.

Day 2 – Tuesday, June 2nd

Designing PowerShell – Bruce Payette

After a nice evening of playing pool with Christian Ritter (And teaching Erik Grina Raassum how to play 😉 ), the first session of Tuesday was Bruce’s. And like always, it was deep into the weeds 🙂 Agenda was:

He talked about all the design goals:

He then rated parts of PowerShell for usability; not all of them were a 5/5 in retrospect 🙂 Pipelining, for example, only got a 3.5/5 because it was not easy to implement and was ultimately implemented using a single thread/process/end approach. But streaming and collections also got a 3/5 because you can’t reliably pass collections through pipelines, there are issues with leading commas, and there’s overhead when copying contents.

But language syntax and quoting got a 4.8/5:

Variables and scoping were 4/5; visibility depends on where and when things are defined. But it supports the configuration shell pattern, and visibility depends on how things are defined.

Types and conversions were 4.5/5; they started out with a very small set but rapidly increased. Type notation is difficult, [int]/[int[]]and [list[int]], and questions like is ‘0025’on the cmdline a string or an integer 😉

And errors and error handling… I can relate that being 3/5 sometimes 😀

And… Performance 🙂 1/5…

Overall conclusion was it’s an average 3.6/5, rough areas, but happy with it 😉

Zero Trust, Five Logins: Under the Hood of Building a PowerShell Module That Audits Your Tenant: Aleksander Nikolic, Gael Colas, Friedrich Weinmann

The presentation, with the longest title ;-), was started by Aleksander:

The Zero Trust Assessment module was a project started by Microsoft and Gael, and Aleksander joined; Friedrich was already involved. It was started by Merril Fernando, based on PowerShell, and most things were based on Microsoft Graph, but not all things were possible with just that.

They jumped into the demo, highlighting the challenges of auditing Azure resources. (Graph vs Azure Resource Graph), Azure Information Protection (Only works in PowerShell v5!), Intune, Exchange Online, Security compliance, and SharePoint Online. A large set of services, but not all of them are accessible via Microsoft Graph, making it more complex.

Aleksander started by showing the module and loading the latest development version:

The goal was to allow users to install the module in the current user and connect using connect-ztAssessment without any Parameters. Things should be simple for customers; everybody should be able to use it. And after authenticating on all services, multiple logins because different services but they made it login to 5 instead of 6 by reusing the Exchange Online, he highlighted that you can’t connect with only reader permissions because of the rights that need consent when using it for the first time.

Aleksander then explained how the data was gathered, stored, processed, and outputted to a nicely formatted HTML output (And by using AI to create and modify its layout)

The code is accessible on https://github.com/microsoft/zerotrustassessment.

Gael took over and discussed all the challenges:

He discussed how loading PowerShell modules works, scripts/assemblies/required modules/Root modules, and demoed the module’s inner workings:

Gael detailed all the challenges for loading modules, stacking up all the DLLs (DLL-Hell), nice insights, and there is no easy solution for most things:

And then it was Friedrich’s turn 🙂

He explained how the tests were built and optimized, mainly for large environments. But also how runspaces work and how progress is monitored, which makes long-running tasks easier. And the challenges you get when running things in parallel, updating status, and preventing things from running again unneeded.

Level Up Your Terminal Experience – Andree Renneus

After lunch, I joined Andree’s session about leveling up your Terminal Experience. He started with all the different types of terminals:

He also showed the different modules; he contributed to a lot of them, too!

He showed how you can discover all the plugins and features of these modules:

It was a very detailed presentation in which he showed how you can expand on your current Terminal settings to make things more discoverable, sometimes it’s more dependent on your use-case, but good to know all these options. It’s a good session to watch again on YouTube and step through it there.

Authoring and using DSC v3 resources – Tess Gauthier

Tess started her session on DSC v3:

She demoed auditing the SSHD_Config as an example for DSC configuration of it, which has different types of formats and is dependent on software versions.

Tess further explained how different parts of the configuration files are changed, and that a backup is created on the first configuration. The different types of resources will give you options for either testing, adding, removing, etc.

She then showed the authoring options for different types of scenarios, that tree-sitter is used for parsing and adjusting the files. Takeaways were keeping resource behavior simple, leveraging canonical properties, and using DSC and SSH resources to audit and configure the SSH server at scale.

Workstation Configuration as Code lifecycle with WinGet – Demitrius Nelon

Demetrius first thanked the community. He was happy to be at PSConfEU for his 5th year 🙂

He explained the configuration as a code concept:

And things have changed since last year:

He demoed configuring a machine, with elevation prompts, and while explaining the steps, the software was installing in the Terminal behind him:

You can now export the configuration of an ARM machine and import it on an x64 machine; it translates that way, but you can also do it in reverse: x64 software will run on ARM, but it won’t be the optimized version.

There is new support for fonts, filtering for those that will work in the newer version of WinGet. Also, the syntax for v2 and v3 is different. There are options to convert, but it is slow.

Challenges and issues:

Things that are being worked on are: Unifying winget export/import, adapted-resource manifests, first-party DSC v3 resources, resource metadata, and DSC v2-style auto-install for V3.

Call to action and links:

IntuneStack – a CI/CD PowerShell workflow for managing Intune policy – Hailey Phillips

Been following this for a while, in finally in person and demoed: IntuneStack!

She explained the Intune workflow of opening the portal, editing policies, saving and praying it works, people calling the helpdesk, etc. 🙂 The drift problem: documented settings differ from the settings actually configured. Rollback is an issue, no undo button in the tenant…

The need for Dev, Test, and Prod environments is there. But what if these were not just environments, and if you could separate different types of profiles using Entra groups and automating that? Splitting users and devices into groups for policies with gates that have success criteria?

Hailey then demoed her solution:

The report side of the different environments, including the success rate with a threshold that allows promoting dev to test, for example, is really nice! The flow:

Spawn of a Shell – Handling Sub Processes – Jordan Borean

Last session of today was with Jordan in the main presentation room:

He explained the differences between executables, batch files, etc., and the difference when starting them with an “&”. The difference between scopes was explained: running things in a Job (Sub-Process). You shouldn’t use Invoke-Expression because it’s not needed and has issues with spaces in the command and with security, too…

Jordan highlighted the use of measure-command with and without a Wait switch for GUI applications that need to finish before exiting… (Including child processes) You can also use -Passthru to start PowerShell with a piped Wait-Process to close when everything underneath is closed. He also showed alternative methods for starting processes using CIM/WMI without using Scheduled Tasks or similar tools.

Command-Line Parameters, Splattings vs variable arrays, and debugging with trace-command were also demoed. Escaping characters, legacy mode usage, and the issues it causes. $PSNativeCommandArgumentPassing was discussed and –% literal mode, didn’t have to use it before, but it’s nice that there are options 🙂

Standard input/output, encoding issues (utf-8/raw) for stdin, reading stdout from processes, encoding stdout with ConsoleEncoding, PowerShell v7.7 preview has $ApplicationOutputEncoding, which makes it easier. Stdout versus Stderr, redirecting to Out-Null of [void], and many more topics! Viewing the YouTube video on the PSConfEU page later is recommended. Jordan explains all the concepts with good examples!

Community Dinner

The dinner was at the Brauhaus Castel, a nice place, and there were train-like busses to get there, but Gijs, Ravi, and I took an Uber. Some pictures of the evening, which we closed at the bar back at the hotel 🙂

Day 3 – Wednesday, June 3rd

May the debugger be with you, 2026 edition – Manfred Wallner

Manfred started the first session of the day, an interactive one 🙂

You can follow along with most of his session using the GitHub link above. (Direct link, you can walk through the different scripts from there) He highlighted the options in the Terminal and VSCode for debugging, viewing variables, watching variables, viewing the call stack, and using breakpoints.

Watch the PSConfEU YouTube channel and check the session there!

Desired State Configuration v3 & Bicep – Andy Jordan

After lunch, I joined Andy’s session:

After walking through the current state, how things work, Andy talked about the why of Bicep and how it actually runs:

The challenges of reaching 100% were also explained, allowing Bicep to handle the translation instead of DSC. For the demo, Andy showed Windows Bicep configuring the current dark mode setting:

The structure of building the configuration and scripts was coded live, and IntelliSense really helped format things correctly and automatically suggested the correct values and options, making things a lot easier 🙂

Lists, Dictionaries, or Arrays – Where the Heck Should I Store My Data? – Christian Ritter

Christian started his session with nicely themed slides:

Luckily, not many slides, but demos 🙂

He explained arrays, their performance, and the benefits. The same for using Generic Lists and things like referencing Variables and slicing. Dictionary/HashTables and their operation were demoed, along with their limitations. Type safety, ordered lists, etc., were demonstrated and explained.

The difference beween Stack and Queue, using Push and Pop, etc.. So many things were shown, but can be viewed in his example scripts from the PSConfEU GitHub repo here.

Side-by-Side PowerShell and Module Environments with multi-pwsh – Marc-André Moreay

This was an open stage session of Marc-André

This makes it possible to run multiple PowerShell v7 versions next to each other, really cool! Installing multiple versions and release channels, and to avoid MSIX installations (for newer versions), it will use the ZIP installer for the user and system scopes. Upgrade and rollback are also possible. Virtual environments are also available, in which certain modules are installed and isolated from your normal module path. (Like a Docker for PowerShell modules)

Download it from GitHub, give your feedback to Marc-André.

PowerShell: Designed for a Messy World – Jeffrey Snover

The second session from Jeffrey:

He told us about how PowerShell was made, designed for the world as it was, and for how it should be 🙂 And he welcomed us to… The world of suck 😀

He touched upon all the things that Microsoft did in the past decades:

He talked about the history, the philosophy, and the extensibility. From the moment the Monad manifesto was written, the first Proof of Concept, public beta, and PowerShell v1 in 2006. The vision and architecture were explained, including DLLs and Cmdlets, the platform, host Cmdlets, etc.

Great overview of how everything is built, the how and the why, and a great talk to watch on YouTube later!

The PoShaKucha presentations: The Stage is yours!

After the talk of Jeffrey, with some added bonus time there, the PoShaKucha sessions started:

Check them on YouTube, the sessions are fast, digestible and fun!

Day 4 – Thursday, June 4th

Arrays, Lists, Hashtables & Beyond – Stephane van Gulick

First session of the last day of PSConfEU:

He had a nice analogy about collecting video games (Collections), the first few slides also displayed that 🙂

He explained how Arrays work for adding things, how to reference them to each other, the static methods, Index elements, sorting, etc.

The game theme continued with Mortal Kombat 3 and how multi-dimensional arrays work:

He also highlighted performance optimization, using Where-Object is slow in large arrays, but the . Faster because it goes directly to the array instead of the Where-Object Cmdlet. IndexOf is faster, but BinarySearch is even faster and only works on sorted arrays.

The analogy for Hash Tables for boxes of games in a closet was also nice, like fighting, strategy, racing, etc. He talked about sorting, ordered (Which was fixed in PowerShell v7, allowing it to be sorted in the order in which it was added, which is not the case in PowerShell v5)

The difference between using Arrays and ArrayLists is that ArrayLists are easier to add, remove, and query their contents.

After that, he mentioned HashSets, and Rob told him it was time to stop 😉

Methods to the Madness – How PowerShell invokes .NET Methods – Jordan Borean

Joined Jordan’s session because I wanted to learn more about this:

He showed how to invoke .NET static methods, reflections, etc.

Many examples, well explained, and I really like the Specter way of presentation (Running code in your terminal alongside the PowerPoint-like slides). The slides are available on the PSConfEU GitHub repo here.

Continuing those uncomfortable Health conversations – Traci Sewell

And then it was time for this great talk, just like previous years, from Traci:

She reflected on the previous ones, noting the phrases that stood out: “It’s ok not to be ok.” But also, no one is indestructible, not being ok is not a weakness, and asking for help takes courage.

These things are how you know you might have a problem when you struggle with these:

The last bullet point of this slide was something my girlfriend often tells me as a thing that she runs into 🙂

This is always a great session, not an IT/Nerdy one, but relatable and makes you think. Thanks, Traci!

Custom PSScriptAnalyzer Rules: From Zero to Everywhere – Christian Ritter

After lunch, I joined Christian’s session about PSScriptAnalyzer:

After the introduction, he explained what Script Analyzer does using a TSA analogy:

He demoed how this works:

Great stuff, I depend on Script Analyzer to help me, and it’s nice that you can learn it for your specific needs for naming, formatting, etc.! The Microsoft Graph permissions Analyzer rule was a super handy example of its possibilities, but Christian mentioned that, while it works, you might not want this running continuously in the background, slowing down VSCode.

Shorten the code

Before the results of the last time, the winner of last year explained how last year’s contest was:

He explained the process, the difference in PowerShell versions, etc. Very to see how he did it and what he learned! And then this year’s competition:

Community Demos

And then the community demos started, 5 minutes each:

Watch these on the PSConfEU YouTube channel! Links with more information for each session (Click on them) are here. And… things you didn’t expect to see: (But this always happens during Ben Reader’s sessions 😀 )

And then you need to present yourself, Christian, Justin, and Jordan, without having time to change 😉

Closing Ceremony

Gael started the closing ceremony:

Wrapping up

And that was my ‘small’ overview of PSConfEU 2026. Can’t wait for PSConfEU 2027 (you should go if you can!). Have a lovely weekend!