Read the demo version.
It will give you a clearer idea of what to expect from the course.

Note: the course is fully delivered in Russian

Alexander I.

This course gave me a clear structure for thinking about asynchronous communications. Within the first week I was already applying the ideas at work.
Anton explained concepts in a way that finally clicked for me.

One big insight: don’t merge two business steps just because they look similar technically.
I’ve started adapting these lessons on the job, and it’s been motivating and rewarding.”

Alexey Ismailov

"One of the biggest insights for me was realizing that many teams rush into microservices without seeing the bigger picture. Sometimes the right choice is a monolith — and thanks to the course, I now understand when and why.

The course also showed me the depth of what I didn’t yet know. It opened a new layer of understanding and helped me see architecture not just as async patterns, but as a whole discipline. I’ll be revisiting the materials for months to come."

Maria Krol

I work as an architect in a telecom company with a huge product full of legacy code, a plugin-based architecture, and almost no documentation. We were preparing for a massive refactor, and I had no idea where to start.

Through the course, I finally understood why our documentation felt unreadable and why diagrams had to be explained over and over. I began cleaning up the docs, which naturally led into planning the refactor starting from the most critical areas.

Another big takeaway was learning when not to use microservices. That alone can save teams enormous costs and mistakes. By going through the full cycle myself, I also gained clarity on where architecture ends and design begins.

The course is incredibly well structured — nothing extra, just focused content and a hands-on project. The additional reading lists after each lesson are amazing.

EventStorming was a real discovery for me. If you want to dive into distributed systems from scratch or level up your current skills, this program gives you a toolkit of best practices you’ll actually use.

"I first heard about the school from a colleague and was skeptical at first. But after the first lesson, I decided to give it a try — and I’m glad I did.

The best part wasn’t just the material, but also the chance to connect with people from different backgrounds and exchange ideas. Anton was always there to explain things all the way through.

The hands-on assignments were top-notch — they gave me the experience I couldn’t get at work until I had done it myself. After the course, my colleague and I reviewed our own system at work, spotted issues we couldn’t articulate before, and came up with a plan to fix them.

It completely changed how I approach architecture decisions, especially when it comes to splitting things into microservices. Highly recommend!

Alexander Verkhovlyad

The course helped me organize my existing knowledge of system architecture and design, while also expanding my toolkit for working with microservices. I practiced DDD techniques, requirement analysis, and breaking systems down into subsystems.

At work, the insights from the course pushed me to improve our architecture and restructure subsystems. On top of that, I really enjoyed connecting with peers and like-minded colleagues during the program.

Pavel Shchegelsky

I’ve always been curious about new technologies and methods, but what really matters to me is practice. This course delivered on all of that.

I had read a lot about Event Storming before, but never had the chance to actually try it. During the course, I finally experienced why it’s such a powerful tool for understanding domains, dependencies, and system behavior.

I also deepened my understanding of the challenges in building asynchronous architectures — and how to avoid ending up with a distributed monolith. Through hands-on work with Kafka and message exchange patterns, I learned how to tackle communication problems more effectively.

On top of that, I got more familiar with the Spring framework while working on assignments. Overall, I don’t regret a single hour spent. I’m very happy with the results and with Anton as an expert.

Artem Lebakov

I really enjoyed the course and got more out of it than expected, even though I didn’t finish all the assignments. A few highlights:

1. I usually work in automation, not system architecture. Still, the course gave me new ways of thinking and helped me see how concepts like coupling apply beyond microservices.
2. I’ve taught a few courses myself, and honestly, this one humbled me — the material and organization were excellent. I’ll be borrowing some of these approaches for my own teaching.
3. Best of all, the course doesn’t just end when it ends. It leaves you with a solid foundation and plenty of material to keep learning from.

Andrey Alenin

In my view, the most valuable aspects of the course are:

1. The relevance of the material — everything Anton covers is something you can apply immediately during the course. Later, when you face these technologies on the job, they won’t come as a surprise because you’ll already have hands-on experience.
2. The practical assignments — they simulate real-world conditions and let you test technologies in a production-like environment. This prepares you for the kinds of challenges that come up in modern IT projects.
3. The holistic approach — by the end, you don’t just practice isolated techniques, you build a working system and learn to see how subsystems interact. It trains you to approach complex systems with a broader perspective.

I got exactly what I was looking for — a deeper understanding of how asynchronous systems work, how to design them, and the pitfalls to watch out for.

Before the course, I only had a rough idea of microservices, often framed through antipatterns. Here, I learned proper architecture principles and got hands-on experience with Kafka.

I’d recommend this course to any developer planning to work with microservices. It’s also a great way to broaden your perspective — this is a hot topic you’ll almost certainly encounter sooner or later. I’d say the course is best suited for mid-level and above.

What I liked most was the homework reviews — very detailed and insightful. The assignments themselves were also great: even if a bit rough at times, they really helped immerse me in the context of building asynchronous distributed systems.

I learned everything I needed to start designing distributed systems — and more. We even covered the internals of code and command/request separation. I’d recommend this course to anyone interested in learning how to build asynchronous distributed systems.

If there’s one thing to improve, it’s the assignments. They already bring a lot of value, but they could be polished further — that’s where the biggest learning happens.

Stanislav Bolsun
Software engineer, Arrival

The course turned out even better than I expected. I especially liked the first part — designing systems “on paper.” It’s such an important step, and I learned a lot from it. Some assignments, like the one on authorization, were tough for many students, but overall the experience was excellent. I’m glad I finished the course with all the assignments done.

Going through this program made me realize how much I enjoy architecture and that I want to keep growing in this direction.

I really enjoyed everything about the course. I want to especially highlight the number of references and the way the material was delivered.

I didn’t look at microservices as a whole system where every layer matters before. After the course, the structure made complete sense. It’s now much easier for me to design complex systems and communications, break down business requirements into clear abstractions, and understand context — sagas, business transactions, design methods, and more.

I’d recommend this program to anyone who wants to approach microservices seriously, not just scratch the surface.

Anton Chuchkalov Software engineer

The course was both fun and insightful — even the business requirements examples made me smile.

I liked that I could get hands-on experience with data streaming and RabbitMQ. It was also very useful to design a system end-to-end before jumping into implementation.

Unfortunately, I didn’t have enough time (or maybe motivation) to try SchemaRegistry or deploy through k8s. Kafka would have been interesting too, but I had already seen it covered in Anton’s streams, so I decided to focus on RabbitMQ.

I didn’t bring the system to a production-ready state — that would have taken too much time and felt unnecessary. Still, I’m happy with the way it works now.

Evgeny Burmakin
Wanna-build web developer

During the course I realized why so many companies struggle when moving from a monolith to microservices. Often, they don’t actually make life easier — they just end up with a distributed monolith that’s even harder to test.

For me, the course cleared up a lot of questions around data exchange between services and how to define a single source of truth.

I’d recommend it to mid-level developers with a few years of experience who feel the need to sharpen their architecture skills but aren’t sure how to move forward. For juniors, it’s probably too early — more of a distraction than a benefit.

Marina Belova developer в servers.com

The course helped me strengthen my theoretical knowledge of asynchronous architecture and see how things actually work in practice. For example: how data is validated, how versions are managed, and how contracts are stored. What kinds of events exist, and how they can be processed. In which cases such architecture is truly useful.

I’d recommend it to mid-level and senior developers, and—perhaps unexpectedly—to product managers as well. There’s a lot here that can be valuable for them too.

Dmitry Matveev Evrone, Potok.Digital

The key takeaway for me was understanding the difference between a distributed monolith and a well-designed microservices system — mainly, the role of a data bus and how services communicate through it.

I’d recommend Anton’s workshop and talks (both live and recorded) on microservices and event storming to web developers and architects. The core ideas are also highly valuable for project and product managers working in IT.

Today, asynchronous microservices architecture and distributed apps are the industry standard. Even if you think you’re still running a monolith, or you’re not sure what you actually have, this course helps you see how the whole machinery works in an asynchronous setup.