PSConfEU 2025

I attended my second PSConfEU event in Malmö, Sweden, and had a great time again! In this (long) blog post, I will recap the four days and share what I saw and learned, the people I met, and things I did during that time.

What is PSConfEU?

It’s an event for all PowerShell enthusiasts hosted in Europe this year in Malmö (Clarion Hotel). It has many sessions and a PowerShell Community Dinner event. Attending sessions allows you to learn, but it’s also about the social aspect.

The day before

I started my journey at Schiphol Airport and flew to Stockholm first. Met up with James Ruskin from Chocolately there at the train station, and we took the train to Malmö. The Clarion Hotel (See picture above) is one of the most significant buildings in Malmö, where the conference will take place, and is conveniently located just a short walk from the train station. Immediately saw familiar faces at the hotel, and we went for lunch in the city. And that’s the PowerShell community, meeting people, having fun, drinking, and there was a lot of food and drinks at the end 😀 And… I finally met Andrew Pla, from the PowerShell Podcast!

Day 1 – Monday, 23 June 2025

Opening ceremony

The session started with a nice video message where AI wrote the presentation 😀 After explaining the ground rules, the locations of the rooms, the types of sessions, and how to install the app for the conference schedule, they discussed the use of Building Blocks and Large Language Models (LLMs) including a nice demo from Rob with a SQL container and querying the participants of the events for data. Barbara also conducted a demo with Copilot / Agentic AI in VS Code, where she created a shiny website.

They then highlighted the PoShaKucha session format, which will take place on Wednesday, in which you can do a short 20-slide presentation in a timed format of 20 seconds per slide. However, there’s also the Open Stage platform, where you can conduct a demo if you’d like.

“Ask the Hivemind” was also discussed. It’s the afternoon session on Monday where you can talk with people, engage, open your laptop, and help each other if you have something you need assistance with.

Additionally, since MCP (Multi-Context Protocol) is gaining popularity, it was also discussed and explained how it works between AO Apps and the MCP server.

And… This year, there was no shortened code contest, but a speed-up code contest. Curious about the results, last year’s were so creative! You can check it out here: https://bepug.odoo.com/speed-up-the-code

And for people who are good at Ping Pong, there is also a tournament in the Games Room this week 🙂 But also one of my oldskool favorites:

Picture of all the speakers and their flags!

State of the Shell – Steven Bucher

After the break, Steven’s session started.

He explained how the PowerShell team is a builder:

Highlights of the session were:

• PowerShell v7.5 and telemetry:
  – PSGallery has 450+ published packages a day
  – 200 million machines using PowerShell v7 monthly
  – 2 billion PowerShell v7 sessions per month

• AZ modules are now in trusted MAR.
• Azure CLI and PowerShell feature update (WAM, Get-AzAccessToken, LTS, Copilot response quality)
• AI Shell
• Desired State Configuration v3
  – Decoupled from PowerShell
  – Resources written in any language
  – Configs written in any language (JSON, YAML, and Bicep)
• DSC v3.1 is GA
• Demo of DSC for starting a web server (IIS)
• OpenSSH for Windows
  – OpenSSH is installed by Default on Windows Server 2025
  – SSH Posture Control supports auditing and configuring SSH server settings on Azure machines

He also highlighted the core fundamentals (Security, Privacy, Quality, and Supportability) of the PowerShell team.

What’s new in WinGet – Demetrius Nelon

After lunch, I attended the WinGet session from Demetrius. He started highlighting the WinGet features throughout the versions of the last years. The latest version, v1.10, has these features:

• Entra ID Support for REST resources
• Native AOT Support
• More functionality moving to COM
  • Supports the PowerShell module

The new Preview version, v1.11, has these new features:

• Microsoft Desired State Configuration (DSC)
• Export local configuration
• WinGet DSC v3 Resources
  • Source
  • Package
  • Admin Settings
  • User Settings File

Luckily, it was not all slides, but a demo, too 🙂 He had to downgrade his internal release, version 1.12, to version 1.11.

He highlighted the WinGet file extension, which will be linked to the Terminal, making it easier to start WinGet configurations.

He demoed exporting all of your Windows settings to a configuration file, which resulted in a large file containing all WinGet and Windows settings in YAML format. He, afterwards, used that configuration file and imported those settings into his DevBox machine.

Questions were:

• Will WinGet support Bicep? Answer: They are working on it, and it might be handed over to DSC directly.
• How about support for fonts? Answer: It’s on the roadmap
• When will the WinGet REST resource be available? Answer: We are having internal discussions on that.
• Can you use it offline or in a private repository on your local machine? Answer: There are examples of using a local Docker container as the source.
• How do you look at the Server and Client configuration? Answer: Windows Server 2025 has built-in support for WinGet and continues to support it.

Practical Linux automation with PowerShell – Evgenij Smirnov

I also enjoy working with Linux. And that’s why I joined this session from Evgenij 🙂

He discussed the transition from PowerShell Core to the current version of PowerShell and what is included in the box today. Windows has approximately 1,800 cmdlets on a clean install, and non-Windows systems have only 285 Cmdlets. And .NET does not have feature parity, .NET classes can’t fix issues like that in PowerShell.

Things that work well:

• Core functionality: Data types, flow control
• Working with File Systems: File content
• Low-level access to data: SQLClient, S.DS.P, Invoke-RestMethod

Things that are missing:

• Disk management, printing, networking, services, tasks, client functionality, security, and certificate management.

Running a native command is something you can do by using Invoke-Expression -Command $CMD -ErrorAction Stop. Prepare the $CMD Variable for logging and troubleshooting.

He demonstrated a few custom functions to run non-native Cmdlets on Linux, showing how to create missing Windows Cmdlets for Linux.

He also highlighted the different types of Package Managers and the complexity associated with them. And I know by experience how frustrating that experience is 🙁

However, the biggest issue is the lack of remote support for Linux systems. Invoke-Command works, but it is not perfect. Building support in your Cmdlets would be a better option; he’s using the Posh-SSH module for that.

Unleashing the Power of Hybrid Management with PowerShell & Azure Arc – Jan Egil Ring

The last session of the day was Jan’s session about Azure Arc and PowerShell:

After a small intro to what Azure Arc is, what Azure Jumpstart is, etc. Jan highlighted all the benefits of it and what PowerShell can do in that context.

He demoed Jumpstart scenarios:

He showed using Custom Script Extension, Run Command Feature (Still in Preview), PowerShell Remoting via SSH, VS Code Remote SSH Extension, Azure Hybrid workers, and Machine Configuration (DSC)

Day 2 – Tuesday, 24 June 2025

PowerShell Terminal UI Design with Spectre Console – Shaun Lawrie

The second day started with Shaun’s session:

He began explaining the steps he took to make his Terminal experience more colorful and customized, but it was the Spectre Console from Patrik Svensson that made these enhancements possible. He highlighted his PwshSpectreConsole story, the website, and the documentation.

He did a demo based on Docker management, showing the graphical possibilities:

It’s incredibly powerful to build the layout and add options and menus. Check out his PwshSpectreConsole!

Optimizing Visual Studio Code for PowerShell, 2025 edition – Justin Grote

Justin had room 3, and it was packed! 🙂

After introducing himself, highlighting the previous VSCode sessions at PSConfEU, and Visual Studio Code itself. The goal is to learn how to configure VSCode, either from scratch or within an existing profile, and to assist in setting up VSCode for a colleague.

Key setup takeaways:

• Visual Studio Code can be installed from an installer or as a ZIP file, which contains a Data folder with all the settings that you can transfer to a new installation.
• Browsing themes allows you to preview them without needing to download.
• Settings Sync using your account will help get your settings in a new installation.
• The Screencast option will show your typed letters

He then demoed setting up VSCode, explaining every step and giving background information on the internals of the PowerShell extension. Other things that stood out (for me) were:

• The Timeline panel on the left displays versions of your scripts that are not in GitHub, offering compare and revert options.
• Git Graph Extension makes Git operations visual and easier
• Compact mode and popping-out Windows
• Crisp Logs Highlighter Extension makes your log output prettier
• Autocomplete on Splatting by creating a variable for it without filling it in and calling it in the command below, also works in Terminal.
• Breakpoints (Conditional, Triggered, and Logpoints) and using the Watch pane to monitor Variables
• Inline Values support extension for showing Variable values.

The PowerPoint presentation can be found here: https://github.com/JustinGrote/PSConfEU2025

Road Trip with Classes: A Fun Ride into PowerShell Mastery – Stephane van Gulick

After lunch, I joined Stephane’s session because I don’t use Classes… Yet 🙂

From 0 to her in 30 minutes was his starting pitch… But no, it’s about getting the building blocks. Why bother?

• Reusability
• Being able to plan/understand constructs
• Reuse existing knowledge for developers of other languages

He highlighted that writing out your patterns and script on paper helps in modelling your code:

He explained the object-oriented programming approach. From PowerShell v5, you could create Classes. “Class Logfile {}” which has methods like “[logfile]::new()”. He continued to explain instanciation, working with Classes, Static properties, Error handling, and the differences in using them.

Deep Dive into Types in PowerShell – Bruce Payette

In the big room, Bruce started his session about Types:

He explained what a Type is, the attributes of a sound Type system, and its aspects. It’s always nice to join sessions from Bruce, always on point with some humor, but with so much knowledge! He explained the .NET (CLR) Type system, how and why things didn’t work out as you would want them to, and the history and design choices behind it, as well as the rise of PSObject and Extension Member Types.

He also demoed using these with nice insights and warnings 🙂

Regular expressions: Feel the fear and do it anyway – James O’Neill

James’ session was replacing Ben Reader’s one, but last minute, he was ready for it 🙂

After introducing himself, he began demonstrating regular expressions in VS Code. He started with simple things, as is usually the case, and then progressed to more advanced topics. Like “James O’Neill” -replace “^(.) (.)$”, ‘$2, $1’ will output O’Neill, James. But he continued with more real-life use-case examples.

But still, even though he explained things pretty well, it’s something you should practice more and always looks more difficult than it probably is 😉

Trick out your Parameters: Transformations, Completions, Validations – Andree Renneus

Parameters are something you use a lot, and that’s why I joined Andree’s session:

After introducing himself, Andree began with the standard validation attributes, such as ValidateSet, ValidateRange, ValidateScript, and others. Argument Completions, which allows for tab completion and a greater user experience. Transformations that will change input data before validation, can convert between data types or different formats to simplify the user experience. He then demoed a few different Parameter types:

Nice thing that he showed different levels of Parameter options, ranging from simple to more advanced or combined with other options, and using Classes. At the end, it will present user input errors, giving users tabable options for Parameters, which is always a good thing 🙂 Good first session!

AutomatedLab – Export – Jan-Hendrik Peters

The last session of today was from Jan-Hendrik about AutomatedLab:

After a brief introduction, he began the demo immediately. He explained the PowerShell module, which originated as a Hyper-V option but is also available in Azure. (More information here: https://automatedlab.org/en/latest/ )

He highlighted the installation of the module, PSFramework (With help from Friedrich Weinmann), Labsources, and headless environments.

He then demonstrated an Azure Automated Lab installation, which he had prepared because Azure takes a bit longer to spin up an Automated Lab installation compared to using Hyper-V. Different types of invoking Lab Cmdlets were demonstrated, along with the security measures employed and key considerations to be aware of. It’s also possible to install software on the machine using the Install-LabSoftwarePackage Cmdlet.

He then highlighted that you can create Custom Roles for things that are not in the library, which makes it flexible, and there are Community contributions already present. The LabSnippets can be defined as ScriptBlocks and can also have dependencies. You can submit a PR to the project to contribute.

Community Dinner

The dinner took place at Slagthuset in Malmö, a nice short walk from the hotel.

It was only inside because…Rain 🙁 But that didn’t stop us from having a lovely evening of random talks, having some beers, and a good dinner, or having fun playing Jenga 🙂

Andrew Pla asked me for a small interview for the PowerShell Podcast bar sessions, it was pretty noisy inside, so we went outside and stood under a tree in the rain 😛 You should be able to find our session at https://powershellpodcast.podbean.com/ or your preferred Podcast platform. (Spotify, in my case)

And during the evening, I heard multiple people telling me that the whole experience was perfect for them as first-time attendees. They felt right at home, welcome, and the vibe is incredible in the PowerShell community. Couldn’t agree more!

Walked back to the hotel, Malmö by night looks nice!

Day 3 – Wednesday, 25 June 2025

Teach Yourself Pester – Rob Sewell, Robert Prüst

First session of the day, teaching yourself Pester, Jakub Jares was sick, and Rob replaced him:

After a small introduction, the session started. Session layout is a follow-along approach, where participants learn the basics and apply them. After installing the Pester module and cloning the repository for the session, we started working in Pester.

We learned how to create tests, use Mocks, and perform more complex testing, among other things. There’s a lot to take in, but I’ll play around with it more! I don’t have a use case at my current job or with clients, but I anticipate having one in the future. We used this repository for this session: https://github.com/psconfeu/2025-Pester-FollowAlong.

When Memory Fights Back – Jonas Sommer Nielsen

After lunch, I joined Jonas ‘ session about memory management:

After introducing himself, with a lovely story about his earlier career and the PowerShell summit, he explained the session. His task was to reduce the size of a cost report, which consisted of large CSV files with millions of lines and long line lengths, while also automating the process. He demoed some test data and his script to work with the data.

He highlighted how the Import-CSV Cmdlet works, noting that every line is an object, and how the Group-Object cmdlet helps. However, during development, he noticed that the speed was acceptable, but the memory usage was 22 GB of RAM, which exceeded the 400 MB RAM limit during automation.

A better solution was to use a Hash Table between importing and exporting the data, which helped in finding unique values and memory usage. But still 1Gb of RAM usage. Additionally, he encountered issues with the maximum 472-character unique key.

He then converted the key to a Hash value instead of combining things to a long (max 472 character) key. That resulted in 200 MB of RAM usage, but the script ran significantly slower due to the Hash conversion and the use of a temporary file on disk.

The final solution was the same script, but writing the temporary file less to disk and buffering helped in achieving better performance. It now runs great in an Azure Runbook. Achieved a 99% memory reduction by utilizing TaskManager, Measure-Command, and Profile for problem-solving, and simplifying the script, which improved script performance and reduced 22 GB of RAM to 221 MB of RAM. Nice!

A Friendly Graph PowerShell Survival Guide – Alexander Nikolic

Microsoft Graph is something that I use often, so I joined Alexander’s session about it:

No PowerPoint stuff, immediately to the demos 🙂 He first highlighted the Microsoft Graph GUI, the Graph Explorer. (Also by opening https:/Aka.ms/ge ) Running queries, but also seeing the PowerShell Cmdlets next to it, really helps in discovering things in Microsoft Graph. Permissions are always something that you need to figure out; the Graph Explorer will always show the required ones. Using the Share button in the query pane is something I’ve never done before, but it’s convenient for sharing with others. He also demonstrated that the Access Token can be used to authenticate in PowerShell sessions and that it can be decoded using JWT.

He showed examples like “Find-MgGraphCommand -Command Get-MgUser,” which displays, for instance, all the permissions required for the specified Graph Cmdlet. Additionally, how to discover Least Privileged Permissions, connect safely, and the changes made in the last few months.

During the session, he demoed multiple issues and inconsistencies in Parameters and Permissions, things that you would expect to work sometimes break things. Additionally, there are different Endpoints, some of which are almost deprecated, and the permissions required for those that are not directly tied to the existing permissions.

It was a great session with detailed information on how to work with and utilize the Microsoft Graph API using PowerShell.

Building a cross-platform OS deployment solution with PowerShell – Michael Niehaus

A Session from Michael is always interesting, so that was my next session to join:

He introduced himself, discussed his background, and recounted his first meeting with Jeffrey Snover. And Michael had a use case for managing MDT on the server side, and PowerShell was the solution. But also for replacing VBScript around 2013, which is still taking place today 😉 He then displayed a Debug Window while starting the Deployment Workbench, and you can see that most of the functionality was based on PowerShell in that.

In 2024, he started working on an MDT replacement called “DeployR”. The solution required a level of compatibility and familiarity with MDT, SSCM, and PSD, as well as Web administration using REST, eliminating VBScript and MMC, and avoiding PowerShell v5.1.

He highlighted the Windows PE headaches, including the need to manually inject .NET 8 and PowerShell 7. The need to include PowerShell 5.1 and the modules, as there is no PowerShell 7 to PowerShell 5 remoting and WMI support, no browser (Only Internet Explorer 11), and issues with PSModulePath. Additionally, the Windows LTS vs. non-LTS releases for PowerShell. (v7.4 vs v7.5)

He showed the scripts, the management website, and the creation of the WindowsPE image:

And demoed a Task Sequence:

The Cross-Platform part is using WSL to generate a Linux “boot image” (Fedora) on the Server-Side, which does PowerShell -> WSL > Shell scripts. This enables the deployment of things like Chrome OS Flex. On the client side, it used Avalonia for the UI. Linux does have its share of headaches, including disk layouts, different file systems, and case sensitivity, among others.

Proxy Functions in PowerShell – Bruce Payette

Another Bruce Payette session, this time on Proxy Functions:

He skipped all introductions and started straight away 🙂

He explained the different scenarios, including caching and wrapper usage. For implementation, you need Parameter passing, streaming pipelines, and code generation. $PSBoundParameters are used for this and steppable pipelines. He then started demoing it 🙂

Conclusion: Proxy functions enable many practical scenarios, but they require additional investments to realize their value fully.

The PoShaKucha presentations: The stage is yours!

These are small sessions, 20 slides of PowerPoint with 20 seconds per slide. Fast, simple, and entertaining!

Cache online data inside your PowerShell module – Leo Visser

Leo discussed an Azure latency calculator Module:

He used the information from Azure and stored it in JSON.

He explained that it didn’t work without internet, he created a module build that imported that data into it, and used a build script for it:

Nice solution for retrieving that data online or from the Module itself!

About_Token_Privileges – Thorsten Butz

Thorsten did his session about Token Privileges:

He talked about User Account Control:

Explained the privileges, such as hotel and keycard usage, in a hotel.

He explained Lee Holmes’s method of activating Token Privileges by showing a Take Ownership example:

He also showed that Robocopy does the same, using the/B switch.

Taming the Matrix with PowerShell – Frank Lindenblatt

I saw his session about it last year at PSSaturday Karlsruhe, but it’s still amazing!

He discussed his background and the main topic: the Smart Pixel Clock.

He demonstrated how the REST API works and how to program the clock.

Last year’s participant awards

The people who did the sessions last year were also rewarded:

Lightning Demo – PDQ Wednesday event

Andrew Pla asked us if we could do a few small sessions for the PDQ Discord, and so we did:

I took some live pictures, and I conducted a small PSCustomObject session. Gijs Reijn did a DSC session, Andreas Dieckmann gave a brief talk about the GUIDv7 module, Christiaan Ritter discussed Custom Objects from another perspective, and Christiaan Piet spoke about using PSScriptAnalyzer.

Great fun, thanks for having us, Andrew!

Day 4 – Thursday, 26 June 2025

Filling in the Gaps of PowerShell: Searching, Updating, and Comparing Object Properties – Tibor Soós

Last day 🙁 Joined Tibor’s sessions at 09:00:

After his introduction, he highlighted missing Cmdlets for searching properties and their values, comparing objects by their properties, adding and updating properties of objects, and keys of hash tables. He then switched to his demo explaining his Search-Property Function:

He explained how searching works, the shortcomings, and how to avoid those. Additionally, it is also essential to understand how the hidden object PSObject works, which contains all the available properties. Searching and updating data using regular expressions (Regex) was also demonstrated, showcasing powerful capabilities.

Comparing things with a Reference Object, containing multiple values, hashtables, etc., worked using his Compare-ObjectProperty Function. This is nice in comparing stuff before and after changing Objects.

The Update-Property Function, which also updates hash tables, was then explained. Powerful stuff, you can see that he has many use cases for it himself.

Good explanation of how things work in his Functions, but also how Objects work and what they can contain that might give you issues while working with them.

Building SOC Tools on Stage – David Sass

Joined the session from David, after checking out of the hotel and dumping my bag:

His goals were to help us, share practices, go open source, and give a tool which isn’t terrible to use 😀 The context was the higher education community in Switzerland, Defender XDR, and Azure Sentinel. He highlighted that Defender is not tuned for the educational space, that it’s slow, and Entra ID is also slow 😉 He then demoed using the PowerShell Notebooks. (I also conducted a small session on that topic, which was featured on Experts Live NL this year.)

You can find examples on https://github.com/switch-ch/SwitchPwshXDRNotebooks. Nice usage of the PowerShell notebooks where he imports the required modules for that notebook. He demoed connecting to the tenant and retrieving data in a PowerShell notebook and enriching that data with a lot of details:

He then calls nested Notebooks as a last part of solving Defender XDR incident, which are being closed with all the gathered details, so that you can start the week clean 😉 His solution does the scanning, researching, labeling, and resolving of Defender XDR incidents. Nice!

Better, Wiser, and Good: Cultivating Empathy and Support in our interactions – Stein Petersen, Traci Sewell

And there are also non-technical sessions at PSConfEU, in the big room, where Stein and Traci started their session:

After a brief introduction, they began the session on adding a new tool to your toolbox: the windows of tolerance.

He highlighted working in Teams, roles, communication, goals, and conflicts, among other topics.

It was a thought-provoking talk from Stein, offering valuable insights and reflections on how we operate as humans. Traci took over and discussed the positive dynamics of teamwork. Recognizing the efforts people take, the balance of giving and taking, and how to build a team. And that members of that team will not automatically become a cohesive unit, will not always like each other, etc.

But also about expectations, impossible deadlines, always-on availability, demanding perfection, and unclear or constantly shifting goals. And agreeing on terms and expectations, having meetings at work that make sense, with room in between them. Setting boundaries and making clear that they exist.

Just like the session from last year at PSConfEU, by Traci, it was good having one like it. The human aspect matters. How to encourage mastery by autonomy and purpose, practicing positive selfishness, mental health, etc. Thanks PSConfEU!

SSH and SSH Arc: What’s new and next – Steven Bucher, Tess Gauthier

The session after lunch was from Steven and Tess:

After introducing themselves, Steven asked who already uses SSH on Windows. The development involved an open-source fork of OpenBSD’s OpenSSH-Portable repository. Why you should use SSH, which is installed by default on Windows Server 2025 with a toggle in the Server Manager console to enable it, and how the groups are configured locally to allow users access to it.

The SSH Server (SSHD) processes incoming connection attempts, runs in the SYSTEM context, and Windows Firewall rules filter network traffic (Private networks by default). It listens for traffic on port 22 by default, but can be configured to listen on multiple ports. The SSHD_Config file holds the configuration.

SSH Posture Control, powered by OSConfig PowerShell Module, which supports audit and configuration, is available from the Azure portal or directly in PowerShell. Use cases for that are security, compliance, and productivity. A case study was based on the “Terrapin Attack” in 2023, targeting key Exchange Pre-Authentication, specifically OpenSSH for Windows, which was patched for strict KEX protocol and ciphers. They demoed adding the policy for Posture Control using the Azure Portal:

They highlighted what’s new and upcoming, too:

• Windows SSH Posture Control (In preview now)
• SSHDConfig DSC Resources in (early) development:
  • Export SSHD_config settings based on SSHD-T
  • Additional global configuration settings for Windows
    • Audit and configure the default shell
  • Coming soon in a DSC preview release

They asked to provide feedback and report any issues. Steven highlighted their investment in Azure for SSH: SSH for Arc-Enabled Servers. You can connect to an Azure ARC-enabled machine through Azure Relay without having to expose a Public IP or ports. Tess demoed connecting to an Azure ARC-managed server using the Enter-AzVM Cmdlet, including proxying RDP:

Award for fastest code

The results for the fastest code were presented:

Community Demos

Ansible enabled through Azure Arc SSH – Frank van Zandwijk

Frank did his session showcasing how to use Ansible together with Azure ARC SSH:

WinBGP (When PowerShell is used to run as a service) – Alexandra Jardon

He explained what BGP means and how his PowerShell service provides network information using the API:

What’s new in Microsoft DSC v3.1 – Gijs Reijn

Gijs, Mr DSC, did his session about what’s new in the latest version of DSC:

Tied Variables – James O’Neill

James started his session by explaining tied Variables and what they mean:

Events? We don’t speak Event-Log here! – Christian Ritter

Christian started his session about registering events:

He demonstrated registering an Event that will monitor the closing of his terminal and then automatically disconnect from Microsoft Graph, for example.

Message of the day AKA MOTD – Marnix Van Lint

Marnix showcased his MOTD approach, which helps with connecting servers and knowing on which server you are. It’s like BGInfo, but for WinRM/Enter-PSSession:

Everyone’s password is 123 – Ben Reader

He started his session with a nice animated page:

He explained how the concept of letting workload identities trust each other by Federated Credentials. Meanwhile, Justin and Christian were building an Ikea cupboard life on stage 😀

Ben’s password may be 123 – but yours shouldn’t be – Bjorn Sundling

Bjorn wanted more passwords:

He explained creating a Password Generator (YaPg) with a Dic file:

Managed Identity Emulator – Justin Grote

Justin demoed his improved Invoke-WebRequest in PowerShell v7.6 in just a few seconds, done 😀

Run PowerShell 7 in PowerGUI – Adam Driscoll

Adam showed that you can run PowerShell v7 in PowerGUI:

Splatting Enhancements – Jordan Borean

Jordan started his session about Splatting and his RFC proposal, good stuff!

Closing session

And after the fun Community Demos, the final session, and the ending of PSConfEU. The Award for the Ping Pong tournament, the Winner was Kevin Bates, but his colleague had to pickup at the prize:

And a special thanks to all the people taking the stage:

Please share your pictures:

All the speakers:

Share feedback in the App:

The organization:

There is a new PSConfEU MiniCon scheduled for October 14, 2025. Last year’s version was great fun!

Thanks to the volunteers and the hotel itself:

Use the mentorship program if you want to do a session next year:

Session recording will be published on YouTube, be patient:

The PowerShell Podcast was also mentioned; I love it!

All the stuff will be published on the GitHub repo, https://github.com/psconfeu/2025 :

Thanks to the sponsors:

And thanks to us all for visiting the conference:

And… The next conference will take place in Wiesbaden, Germany. June 1st, – June 4th 2026

Wrapping up

And that was my long recap of the PSConfEU event, you should attend next year in Germany! Have a lovely weekend!

Sharing is Caring:

0 Shares

0

0

0

More

Sharing is Caring:

Facebook 0

Twitter 0

LinkedIn 0

Copy 0

Reddit 0

Email 0

WhatsApp 0

Telegram 0

Print 0