The 3rd .NET conference dedicated to practical experience of solving business challenges with .NET or technical challenges in .NET application

Some pictures from the last conference

See 182 more on our Facebook page
Last year speakers and talks, Poland

Senior Software Developer
Blog, Czech Republic

Principal .NET Developer
@Szer, Ireland

Staff Software Developer

Senior Software Engineer
@Ak Bars Digital Technologies
@EgorBo, Belarus

Software Engineer
Program Committee
Sergey Tihon

Microsoft F# MVP
Solution Architect @EPAM Systems
Ivan Antsipau

Independent Consultant in Cloud Architecture
.NET User Group Belarus
Polina Ruban

Software Engineer
Anatoly Popov

Director of Engineering @IDT
Member of .NET Foundation
Dylan is a developer and systems architect who has been building websites and web applications since 1992.
He's worked and spoken on everything from distributed systems and hypermedia APIs to developer culture, Conway's Law and the history of the world wide web.

He lives and works in London, and when he's not writing code he plays guitar and writes songs. About code.
We've all heard of the idea of 'software architecture'. We've read books about domain-driven design and event sourcing, we've been to conferences and learned about micro services and REST APIs. Some of us remember working with n-tiers and stored procedures… some of us are still using them. But the role of a systems architect is still one of the most misunderstood things about the software development process.

What does the architect actually do? If you're working with a systems architect, what can you expect from them? And if you are a systems architect, what are your team expecting from you?

In this talk, Dylan will share his own insights into the idea of architecture as part of a software development process. We'll explore some popular architectural patterns and processes — and a couple of obscure ones as well — and look at how, and when, you can incorporate those patterns into your own projects. We'll talk about how the idea of software architecture has changed over time, and share some tips and advice for developers who find themselves working with architecture as part of their role.
Author of the Pro .NET Memory Management book.
Programming for over a dozen years, solving performance problems and architectural puzzles in the .NET world, speeding up web applications.

Independent consultant, blogger, speaker and fan of Twitter.
He also shares his passion as a trainer in the area of .NET, especially about application performance and diagnostics.
Microsoft MVP in the Visual Studio and Development Tools category.

Co-founder of initiative.
Managed pointers, in the form of ref variables, existed in .NET since the very beginning. But only recently they gained much bigger interest - there are such constructs like in parameters, local ref variables and readonly refs. Moreover, recently so-called ref structs were introduced and in the context of Span<T> type one could hear of byref-like instance fields. We can hear about those "ref-something" things a lot, but should one really care?

Konrad believes so, as all those changes perfectly fit into the ongoing process of speeding up .NET and its performance possibilities. There is a lot of ways to optimize your code with the conscious use of those constructs, although some caveats exist that we should be aware of. Let Konrad introduce you to such "ref-world"!
As a former Technical Consultant at Microsoft, Dan helped hundreds of Microsoft partners plan, design, architect and deploy cloud and hybrid infrastructures and software solutions.

He delivered hundreds of on site trainings to partners and talked at different conferences.

From a technical perspective he tries to stay up to date with everything around .Net Core, Angular, software architecture and Microsoft Azure.

He recently founded a startup called Codewrinkles with the mission to help people around the world become software developers.
When running a microservices / service oriented architecture thinking about the gateway to our services is one of the first things to take into considerations. Building an API gateway is not an easy task since we need to take several topics into considerations like authentication / authorization, load balancing, service aggregation, service discovery rate limiting and so on. Fortunately we don't need to re-invent the wheel since the Ocelot API gateway library is playing well together with ASP.Net Core and allows us to easily configure all the previously mentioned topics.

Join Dan in this talk to discover together how we can easily build powerful API gateways that hold the door to our services!
Mikhail Shilkov is a Microsoft Azure MVP, Russian expat living in the Netherlands. He is passionate about cloud technologies, functional programming and the intersection of the two.

You can find him blogging at or presenting the stories of serverless and functional adoption at conferences and meetups.
Mikhail is a co-host of the meetup "F#P Eindhoven" and the conference "ServerlessDays Amsterdam".
Astrata collects telemetry from tens of thousands of vehicles throughout Europe. For many years all the back-end services were hosted on bare-metal self-managed hardware.

By the end of 2017, the decision was made to join the cloud era and move all business-critical workloads to Microsoft Azure. And along the migration, applications were modernized to leverage higher level Platform-as-a-Service whenever feasible.

During this session Mikhail will guide you through this migration story from making the decision to lessons learned, looking from developer and operations points of view.
Alex is an application development enthusiast since the late nineties and worked as a lead developer and architect at large enterprises and small companies. He spends his time teaching other developers the details of the Microsoft development platform and frameworks, and coaches architects to design and build modern distributed applications at cloud scale.

He has received the Microsoft Most Valuable Professional award for Visual Studio and Development Technologies 12 times.

In his spare time Alex likes to participate in all kinds of sport, and loves playing and programming new and retro video games.
Do you have any idea how your ASP.NET Web Apps and APIs are functioning? Are they behaving healthily or in a degraded state? You might be able to tell from log information and telemetry data, but why not have them tell you how healthy they are themselves? ASP.NET Core 2.2 introduces health endpoints that let your apps and APIs do just that.

In this session you will learn how to make health checks an integral part of your solution. We will cover various types of health checks ranging from internal status, such as memory thresholds, to health based on external dependencies, such as databases and HTTP endpoints. Finally, you are going to see how this all can be used in a container cluster to allow the orchestrator to check for liveliness and readiness based on your health endpoints.
For the last few years Michael started filling in the GraphQL gaps on the .net Platform resulting in the Hot Chocolate open source project that introduced advanced GraphQL concepts like real-time web communication, schema stitching and more. Apart from that he has over 16 years' experience in professional software development for companies of all sizes.

Currently Michael is working as trainer, consultant and speaker in the Microsoft environment.
Before becoming a consultant, Michael worked at Open Text as a software architect in the web content management department.
GraphQL is a great way to expose your APIs and it has changed the way we think about consuming data over HTTP. With GraphQL we want to have one schema that provides all the data to us in a consistent way, enabling us to drill into the graph and fetch with one request what we actually want instead of having to issue multiple requests. In the real world, however, we more often build small services that serve certain use cases. Simpler services are easier to maintain and can be deployed more rapidly. Moreover, we often also want to use external services that are not built by us. Ultimately, we will end up with multiple APIs again. The solution for this dilemma is schema stitching.

This talk will explore the schema stitching capabilities on ASP.Net Core with Hot Chocolate. We will show how you can set up a Hot Chocolate GraphQL gateway in under 5 minutes and move on to the various stitching scenarios. This talk introduces simple auto-stitching scenarios and goes on to demonstrate how you can rewrite your GraphQL APIs into something truly new.
Steve Gordon is a Microsoft MVP, Pluralsight author, senior developer and community lead based in Brighton. He works for Madgex developing and supporting their data products built using .NET Core technologies.

Steve is passionate about community and all things .NET related, having worked with ASP.NET for over 15 years. Steve is currently developing cloud-native services, using .NET Core, ASP.NET Core and Docker. He enjoys sharing his knowledge through his blog, in videos and by presenting at user groups and conferences.
Steve is excited to be a part of the .NET community and has recently founded .NET South East, a .NET Meetup group based in Brighton. He enjoys contributing to and maintaining OSS projects, most actively helping save lives with open source software and the Humanitarian Toolbox.

You can find Steve online at his blog and on Twitter as @stevejgordon.
In the world of cloud-native, distributed systems, we often find ourselves communicating over HTTP. What seems like a simple requirement can quickly become complicated! Networks aren't reliable and services fail. Dealing with those inevitable facts and avoiding a cascading failure can be quite a challenge. In this talk, Steve will explore how we can build .NET Core applications that make HTTP requests and rely on downstream services, whilst remaining resilient and fault tolerant.

This session will focus on some of the improvements which have been released in .NET Core and ASP.NET Core 2.1, such as IHttpClientFactory and the new, more performant socket-based handler. Steve will identify some HTTP anti-patterns and common mistakes and demonstrate how we can refactor existing code to use the new HttpClientFactory features. Next, Steve will demonstrate Polly; a fantastic resilience and transient fault handling library which can be used to make your applications less prone to failure. When integrated with the Microsoft HttpClientFactory; wrapping your HTTP calls in retries, timeouts and circuit-breakers has never been easier!

If you're building services which make HTTP calls, then this talk is for you!
Tomasz is a professional developer whose main areas of interest are F# and Functional Programming in general.
As a Senior Software Developer at Datto he applies F# to tackle problems from various areas.

In his free time, apart from contributing to OSS projects and learning new tech stuff, he enjoys lifting weights as well as dancing.
During this talk you'll learn what SAFE Stack stands for. You'll see how to create web applications in F# on both client and server side. Following a simple Model-View-Update pattern that was inspired by Elm language you'll discover that it's fairly easy to create rich clients. On the server side we'll build the solution on top ASP.NET Core.

Starting with some theory, we'll move to a practical example with live coding to develop the app from scratch.
Working in In love of pragmatic-oriented programming. Current production language of choice - F#.
I will talk about differences between TPL Tasks, F# Asyncs and Hopac Jobs. What is the strongest sides for each of them. How selective asynchronous programming model could be handy.
Purpose of my talk is to shed the light on other ways to dealing with async in .Net.
.NET developer at Kontur. Works on a common infrastructure, develops the cloud-based hosting platform.

Is interested in .NET and Windows internals and uses this knowledge in production.
For monitoring the apps' performance it is useful to watch their system metrics: memory consumption, CPU utilization, network resource consumption, garbage collector's work. It can easily be done using Task Manager, Process Explorer, PerfMon, and other GUI tools. But in order to send these metrics to Graphite, for example, or to write it to your app's log you need to know how to collect these metrics from the code. It would also be good if metric-collecting tools were not interfering with your app's performance.

In this talk Evgeny will tell:
- what are the differences between various system metrics;
- which mistakes in metric collecting do not allow you to see performance issues;
- which performance issues do Process and Performance Counter classes have;
- what is the internal design of Performance Counters and how to work with them correctly and effectively.

We will also knock together different ways of collecting metrics in benchmarks.
Passionate .NET developer dreaming about time travelling and teleportation.
Becomes a superhero with a speed superpower when hearing a magic word "deadline".
A rare .NET developer thinks about application domains, what for they were created and what are the internals of them. Meanwhile, with a release of the .net core, such aspects of workig tih assemblies like loading, unloading, isolation and security were changed. And now one must use another technics to find out way to go.

During talk we will remember what are the application domains and what is the state of the art in the .net core. We will discuss what for should we use AssemblyLoadContext class which is currently a new paradigm of the load contexts.

Will learn:
- that there are no more application domains in .net core;
- how to work with dynamically loaded assemblies in the .net core;
- new technics how to load and unload assemblies, make an isolation and security.

All of the above will help us to better understand how .NET Core and .NET Framework are working internal.
Frantisek is with Microsoft for more than 6 years. He codes in .NET for more than 10 years, worked on front-end as well as backend systems.

Event sourcing and event driven systems were inspiring him for a long time and reading about it was just beginning.

He works in contacts team and was one of the key persons responsible for developing a system for managing contacts, groups, relationships for Skype consumer.
The talk goes deeply into the case study published on Azure blog ( It covers Frantisek's journey from the previous request-driven based to the event-driven based system leveraging Azure CosmosDB capabilities. It is split into 3 parts: Why/What/How.

The "Why" part shows the issues Skype team had with running request driven system (Frantisek was responsible for building it, too). Based on the lessons learned by developing and running previous system, he has got a chance to design the new event-driven system which should address all the issues they had. This brought with itself many challenges but also gave the team many options and benefits. Frantisek will cover this in "What" part. The final "How" part shows how Azure CosmosDB with change feed fits into event-driven system as a database storage, how it helped to meet all requirements we had on the system. Together with this he'll show their solutions to several Dev/Ops aspects of the system.
Egor is a software engineer with more than 10 years of experience.
He works on Mono and .NET projects at Microsoft.
While .NET 5.0 is basically the .NET Core vNext it will also offer a lot of new awesome features. One of them is "switchable runtimes" so you will be able to easily switch to Mono-as-a-VM without any code modifications for AOT, LLVM, WebAssembly targets and more.
Egor is currently working on .NET 5 at Microsoft so he is going to share his experience and tell about challenges he faced.
12 years of experience in software development for supporting cosmic systems on the ground.
When people talk about something very complex and incomprehensible, they often call it Rocket Science. But in space, testing remains an important and necessary action.

Alexey will tell about how it works, what features it has and why it is not so scary when you immerse yourself in it.
Be the first to know the news!
Become a future partner
Ping Misha Malikin, our Partner Account Manager:
+375 29 678-56-34,
Previous years' partners
IT-hub in Eastern Europe
Belarus is well know as a highly developing IT-hub with world famous products & startups. In fact it is :

• A country with 1300+ IT-companies & 105 000+ employees
• Takes #37 position among 190 countries in "Doing Business" World Bank ranking
• A homeland of such companies & startups, as EPAM, Wargaming, IBA Group, Flo, MSQRD, Juno, etc.

Belarus is also well known for its solid engineering and open-source community:

• 70+ user groups and communities;
• SPACE Production — tech event venue and organizer of tech-conferences; — online media-platform sharing local news and delivering any kind of content to Belarusian tech community.
30 days visa-free
If you fly to Minsk airport from any country except Russia & your stay lasts up to 30 days (including arrival & departure dates), the visa will be stamped to you free of charge at Minsk airport! This concerns 74 countries' citizens.

Explore the city and enjoy your free time with these handy guides:

Minsk City Guide
Go to Belarus!
SPACE Production is a professional team which stands behind a huge number of IT conferences and meetups.
.NET User Group is a group of people who meet regularly to discuss the use of .NET, share knowledge and experience.
Lera Zaitseva
Content and organisational information
Misha Malikin,
Partnership and corporate tickets
.NET Summit Code of Conduct
.NET Summit is a community conference intended for networking and collaboration in the developer community.

We value the participation of each member of the community and want all attendees to have an enjoyable and fulfilling experience. Accordingly, all attendees are expected to show respect and courtesy to other attendees throughout the conference.

To make clear what is expected, all delegates/attendees, speakers, exhibitors, organizers and volunteers at any .NET Summit event are required to conform to the following Code of Conduct. Organizers will enforce this code throughout the event.

.NET Summit is dedicated to providing a harassment-free conference experience for everyone, regardless of gender, sexual orientation, disability, physical appearance, body size, race, or religion. We do not tolerate harassment of conference participants in any form.

All communication should be appropriate for a professional audience including people of many different backgrounds. Sexual language and imagery is not appropriate for any conference venue, including talks.

Be kind to others.

Do not insult or put down other attendees. Behave professionally. Remember that harassment and sexist, racist, or exclusionary jokes are not appropriate for .NET Summit.

Harassment includes offensive communication related to gender, sexual orientation, disability, physical appearance, body size, race, religion, sexual images in public spaces, deliberate intimidation, stalking, following, harassing photography or recording, sustained disruption of talks or other events, inappropriate physical contact, and unwelcome sexual attention.

Exhibitors in the expo hall, sponsor or vendor booths, or similar activities are also subject to the anti-harassment policy. In particular, exhibitors should not use sexualized images, activities, or other material. Booth staff (including volunteers) should not use sexualized clothing/uniforms/costumes, or otherwise create a sexualized environment.

Be careful in the words that you choose.

Remember that sexist, racist, and other exclusionary jokes can be offensive to those around you. Excessive swearing and offensive jokes are not appropriate for .NET Summit.

Thank you for helping make this a welcoming, friendly event for all!

Need Help?

Contact the manager of the event:
Corporate tickets booking
Ticket type & price (inclusive of all taxes)
Submitting the form indicates you agree with our Privacy Policy