Software development is one of those professions where the ground constantly shifts under your feet. New frameworks appear, languages evolve, and tools that felt cutting-edge two years ago suddenly feel ancient. One of the best ways to keep up with that pace is to step away from the daily backlog and spend some time learning from others in the community.
Recently, I had the chance to attend Swetugg 2026 in Stockholm, a conference known for its strong focus on the .NET ecosystem and real-world developer experience. The event brings together a wide range of speakers covering everything from AI and cloud architecture to developer productivity and software quality. The sessions range from deeply technical topics to broader discussions about how we work and collaborate as developers.
Below are five sessions that stood out and provided interesting insights:
Can You Keep a .NET Secret? Managing Application Configuration with Azure
One of the sessions that resonated strongly was “Can You Keep a .NET Secret? Managing Application Configuration with Azure” by Lindsey Broos.
Application configuration and secret management are topics that often start simple but quickly become complicated in real-world environments. As applications grow and move to the cloud, managing things like API keys, connection strings, and environment-specific settings becomes a real challenge.
This session explored how services within Azure can help manage these concerns in a more structured and secure way. Instead of storing secrets in configuration files or environment variables scattered across systems, centralized services allow teams to manage configuration and sensitive values in a controlled manner.
What made the talk particularly interesting was the practical perspective. It demonstrated how developers can integrate configuration services directly into .NET applications, enabling secure access to secrets while keeping deployments flexible across environments.
Optimizing Your HttpClient Usage
Another highly practical session was “Optimizing your HttpClient usage” by Nico Vermeir.
The HttpClient class is used everywhere in modern .NET applications, especially when working with APIs or microservices. At first glance it seems like a simple tool: create a client, send a request, process the response. However, the session highlighted how easy it is to misuse it.
A common mistake is repeatedly creating and disposing HttpClient instances. While this looks correct from a resource management perspective, it can actually lead to issues such as socket exhaustion because of how connection pooling works internally.
The talk walked through best practices such as reusing clients and using tools like HttpClientFactory to manage connections properly. It also explored resilience patterns, including retry mechanisms and circuit breakers, that help applications handle unreliable network calls more gracefully.
For many developers, the biggest realization was that performance issues often come from subtle implementation details rather than complex algorithms.
.NET Aspire: Beyond the Introduction
The session “.NET Aspire Beyond the Introduction” by Chris Klug focused on a technology that is gaining a lot of attention in the .NET ecosystem: Aspire.
Distributed systems have become the default architecture for many modern applications. Microservices, containers, and cloud services provide incredible flexibility, but they also introduce a significant amount of complexity.
This talk went beyond the basic introduction to Aspire and explored what happens behind the scenes. It showed how developers can extend Aspire with custom resources and integrations to better match the needs of their own systems.
The session made it clear that Aspire aims to improve the developer experience around distributed applications, making it easier to orchestrate services, observe system behavior, and run complex architectures locally during development.
The Best Ways to Use the Latest OpenAPI Features in .NET 10
API documentation and discoverability remain essential in modern systems, especially when multiple teams or services interact with each other. That’s where OpenAPI comes in.
In “The best ways to use the latest OpenAPI features in .NET 10”, Sander ten Brinke explored how the OpenAPI ecosystem continues to evolve within .NET.
The session demonstrated how developers can take advantage of new features in the framework to generate more accurate API specifications automatically. This helps improve API documentation, client generation, and overall maintainability.
The talk also highlighted how integrating OpenAPI more deeply into the development workflow allows teams to detect breaking changes earlier and maintain better communication between backend and frontend teams.
In other words, API documentation should not be a static artifact, it should be a living part of the development process.
Your Testing Strategy Is Broken — Let’s Fix It
Testing is one of those areas where nearly every team believes they are doing the right thing… until something breaks in production.
In “Your Testing Strategy is Broken — Let’s Fix It!”, Luise Freese challenged some of the common assumptions around testing strategies.
The talk explored how teams often become obsessed with metrics like test coverage while missing the bigger picture. Having hundreds of unit tests does not necessarily mean the system is well tested if those tests do not reflect realistic scenarios.
Instead, the session emphasized designing tests around behavior and integration points (places where systems interact and failures actually occur).
It was a refreshing perspective that reminded everyone that good testing is less about quantity and more about thoughtful design.
Final Thoughts
Attending Swetugg 2026 was a fantastic experience. Conferences like this provide something that is difficult to replicate elsewhere: a space where developers can exchange ideas, learn from each other’s experiences, and step back from the day-to-day details of writing code.
Beyond the sessions themselves, the conversations between talks are often just as valuable. Hearing how other teams solve similar problems, discovering new tools, and gaining fresh perspectives on familiar technologies can spark ideas that influence your work long after the event ends.
Events like Swetugg remind us that software development is a collective craft. No single developer or team has all the answers, but by sharing knowledge and learning from one another, the entire community moves forward.
And that’s exactly why attending conferences like this is something I would strongly recommend to every developer.
Subscribe to our RSS feed
Talk to the author
Contact Louis
Developer