Skip to main content
Next edition: Autumn 2026

Nail Your Complex
Go Backend

Become the backend engineer that companies beg to hire.
Learn to design and build backends that survive production.

1-minute setup. The CLI prepares the whole project.
Your IDE, your tools. Solo or with your AI agent.
A safe environment. Break things here, not at work.
Never stuck. AI mentor, plus the authors on Discord.

Next cohort: Autumn 2026. Join the waiting list now and get the ebook and the mini-course right away.

Avatar 0Avatar 1Avatar 2Avatar 3Avatar 4Avatar 5Avatar 6Avatar 7Avatar 8
🔥 789 developers are already on board
7,400+ Go devs trainedWatermill 9,888Wild Workouts Go DDD example 6,448270K+ yearly blog readers

Engineers learning with us work at

Atlassian1PasswordAnchorage Digital
LufthansaDatabricksQualcomm
SinchHadrianDiscovery
ZscalerEricssonNord Security
KongSumUpVinted
GrabEpic Games

One of the most valuable backend courses I've taken. The training combines solid theory with practical implementation, making it easy to apply the concepts directly to real projects. I've already used several of the patterns and architectural approaches at work with great results.

The content is relevant, well-structured, and focused on real-world challenges. I highly recommend it to backend engineers who want to improve their system design and architecture skills.

Thanh Dao

Thanh Dao

Software Engineer, Airtasker · Verified buyer

Complex domains need
real engineering

"Is there a way to build software fast without making it a maintenance nightmare?"

"Is the way I've been coding for the last 5 years the best way? Or are there teams that do it better?"

A couple of years ago, we worked on a product that succeeded quickly, but at some point hiring more people to write more code didn't help anymore. Despite best efforts of very talented people, it ended up stuck in maintenance mode for years.

AI won't fix this. It can produce code faster than you, but it will surface those architectural problems faster too. System design and domain modeling are the decisions you have to make. You can't afford to trust in ‘You are absolutely right.’

Most engineers never get the chance to work on a team where adding a feature doesn't break three other things. You repeat the same patterns because there's no time to learn through trial and error on production code.

The Domain Engineer gives you that missing experience. You work through the same decisions a well-run team would make, compressed into exercises you can do on your own schedule.

In this training we cover timeless skills that are a must-have for every engineer who wants to own technical decisions, not just be a coder. Doesn't matter if you are writing code by hand or doing AI-assisted coding.

You'll learn how to:

Find the right boundaries. Split modules in a way that speeds up, not slows down development.
Model the domain code. Keep business rules in one place, not scattered across services.
Write idiomatic Go. Clean patterns that were developed exclusively for Go, not ported from Java.
Know when to avoid overengineering. And when simpler patterns are enough.
Model the system on a high level. From Event Storming sessions to code running in production.

No more "I understand the theory but..."

Gopher with cup

Every exercise is a change
you'd ship at work.

You build a food delivery platform module by module, with feedback in seconds. Theory comes in small pieces, right when you need it.

you@home: ~/trainings/the-domain-engineer
$ tdl training run
project/backend/billing/adapters/tax/client.go | 79 ++++++++++++++++++++++++++
project/backend/cmd/main.go | 2 +-
2 files changed, 80 insertions(+), 1 deletion(-)
 
Exercise ready.
 
Press ENTER to run your solution or q to quit
 
--------
 
Setup
Issue receipt with all line item types
Tax rates match line item types
Line item 'Delivery Fee': expected tax_rate '0.23', got '0.08'.
The tax API returns different rates based on line_item_type and country.
 
Delivery receipt tax rates match line item types
Getting document UUID by external reference 01a0787d-6d14-7677-b3a9-9d7718aab437
Delivery receipt line item 'Delivery': expected tax_rate '0.23', got '0.08'.
The tax adapter should map line_item_type to the correct tax class when calling the external API.
 
 
--------
FAIL
 
Press ENTER to run solution again or q to quit

Tests mirror requirements. Each check is a real business rule of what you build. You see what fails, and learn what to fix.

you@home: ~/trainings/the-domain-engineer
$ tdl training run
project/backend/billing/adapters/tax/client.go | 79 ++++++++++++++++++++++++++
project/backend/cmd/main.go | 2 +-
2 files changed, 80 insertions(+), 1 deletion(-)
 
Exercise ready.
 
Press ENTER to run your solution or q to quit
 
--------
 
Setup
Issue receipt with all line item types
Tax rates match line item types
Delivery receipt tax rates match line item types
Getting document UUID by external reference 01a07878-ddd4-7cf8-93c1-5d4d84505c15
 
 
--------
SUCCESS
 
You can now see an example solution on the website.
 
Press ENTER to go to the next exercise, s to sync with example solution, r to re-run solution or q to quit

Feedback in seconds, not in next week's code review. One click verifies your code. Once green, another click takes you to the next exercise.

project [~/trainings/the-domain-engineer/project] - billing_cycle.go
project
backend
billing
cmd
common
delivery
orders
settlements
adapters
api
app
domain
billing_cycle.go
billing_cycle_test.go
iban.go
iban_test.go
legal_entity_uuid.go
partner_type.go
module.go
tests
Dockerfile
reflex.conf
svc.go
docker-compose.yaml
go.mod
go.sum
Taskfile.yml
billing_cycle.gobilling_cycle_test.goclose_billing_cycle.go
100func (bc *BillingCycle) Close() error {
101 if bc.closed {
102 return errors.New("billing cycle already closed")
103 }
104 
105 bc.closed = true
106 
107 endDate := time.Now().UTC()
108 bc.endDate = &endDate
109 
110 return nil
111}
112 
113func (bc *BillingCycle) Settle() error {
114 if !bc.closed {
115 return errors.New("billing cycle is not closed")
116 }
117 if bc.settled {
118 return errors.New("billing cycle already settled")
119 }
120 bc.settled = true
121 return nil
122}
backend/settlements/domain/billing_cycle.goLFUTF-8Tab

A codebase you could see at your job. Orders, delivery, billing, settlements. A modular monolith built the way we build production systems. The boring parts are on us. You write the important code.

The Domain Engineer 12-settlements - 01-project-billing-invoice-support
Billing Now Issues Invoices Too

In this module, we'll close billing cycles and issue invoices for our partners. Here's how money and documents flow between the parties:

👤 Customer 🏢 Platform 🍕 Restaurant 🛵 Courier 💵 $100 💵 $80 💵 $15 📄 $5 commission invoice 🧾 $100 receipt 📄 $15 delivery invoice

Settlements will call billing to create the invoice documents: commission invoices for restaurants, delivery invoices for couriers.

But billing only knows how to issue receipts today. So before we add proper logic in the settlements module, we'll extend billing to support invoices.

Same Process, Different Document Type

Receipts and invoices share most of their structure: seller, buyer, line items, tax breakdown, and external reference. The differences are small. Invoices use different validation and a different document type (for downstream filtering and reporting).

We'll use the same DocumentFactory but add a new NewInvoiceBuilder method, mirroring NewReceiptBuilder.

NewReceiptBuilder rejects buyers with a tax ID (receipts go to consumers). NewInvoiceBuilder skips that check because invoices are issued to entities that have tax IDs. That's the only domain difference.

Just enough theory. See a distilled explanation in plain English, diagrams, and Event Storming boards before the exercise. Read a bit, then go build it.

We've been shipping production systems for 17 years. The Domain Engineer lets you skip the mistakes and dead ends we already made.

What will you learn?

Each exercise is a focused, small change. You can finish something meaningful even in a 5-minute session.

Together, we'll build a global food delivery platform from scratch. ~20,000 lines of production Go. Each module needs different patterns. You'll learn when to use which.

The Domain Engineer is a cohort-based training. Modules start releasing weekly after the sale ends. Finishing a week's work requires between 4 and 6 hours of coding for a senior developer.

Going with the cohort is optional. You can go over the exercises at your own pace.

See the full agenda below.

What you will learn
  • Know when DDD adds unnecessary complexity and use simpler patterns instead
  • Apply only the DDD patterns you need, from light tactical patterns to full strategic design
  • Common traps making codebases unmaintainable
What you will learn
  • Know which patterns are worth adopting and which add unnecessary overhead
  • Present improvements in terms your team and management care about
  • Introduce changes incrementally without disrupting ongoing work
What you will learn
  • Apply Clean Architecture so domain logic stays independent of infrastructure
  • Create clear boundaries between domain, application, and infrastructure layers
  • Organize code that multiple teams can work on without stepping on each other
What you will learn
  • Use bounded contexts to split large projects into independent modules that teams can own
  • Define clear contracts between different parts of your system
  • Decide when to extract a separate module and when to keep things together
What you will learn
  • Model business rules that reflect real-world problems
  • Use factories to handle complex object creation with external dependencies
  • Write tests that catch business logic errors, not only technical bugs
What you will learn
  • Design the transactional boundaries of your domain model
  • Protect data consistency in complex scenarios without database locks
  • Handle concurrent operations and bulk updates efficiently
What you will learn
  • Decouple your domain from database implementation details
  • Make your logic code easier to test
  • Handle complex queries without leaking infrastructure details into your domain
What you will learn
  • Understand how Event Storming sessions reveal domain complexity
  • Transform sticky notes and events into concrete bounded contexts and aggregates
  • Bridge the gap between business understanding and technical implementation
What you will learn
  • Build a ubiquitous language to communicate effectively with product managers, designers, and domain experts
  • Reduce time spent on requirement clarifications and bug fixes
  • Create a shared vocabulary that evolves with your project
What you will learn
  • Distinguish core domain from supporting code to focus your design effort
  • Apply complex patterns only where they have the highest impact
  • Stop wasting time on areas that don't need sophisticated modeling
What you will learn
  • Understand what users need, not only what's in the ticket
  • Extract requirements that translate directly into code structure
  • Collaborate with domain experts to build better models
What you will learn
  • Add new features without breaking existing functionality
  • Refactor legacy code incrementally using DDD principles
  • Plan changes that won't require massive rewrites later
What you will learn
  • Collaborate with other teams without tight coupling
  • Define integration patterns that won't break when other teams change their code
  • Protect your code from breaking when external systems change
What you will learn
  • Learn how to emit domain events to decouple parts of your system
  • Understand the basics of event-driven architecture
What you will learn
  • Understand facts and myths about CQRS
  • Separate read and write models for better separation of concerns
  • Use read models for easier querying and reporting
What you will learn
  • Call external APIs from your domain without creating tight coupling
  • Shield your domain from external API changes and data models
  • Design adapters that isolate your core business logic
What you will learn
  • Map between database models and domain objects effectively
  • Choose between ORMs, query builders, and raw SQL for your domain complexity
  • Avoid the common pitfall of anemic domain models
What you will learn
  • Handle external calls from domain entities without violating DDD principles
  • Design entities that can make decisions based on external data
What you will learn
  • Inject configuration into entities without breaking encapsulation
  • Handle feature flags and environment-specific behavior in domain code
  • Design entities that adapt their behavior based on runtime configuration
What you will learn
  • Write tests that verify business rules, not only technical correctness
  • Test complex domain scenarios without complicated test setup
  • Use domain tests as living documentation for business rules

No prerequisites from our other trainings
The Domain Engineer builds on the project from our Go Backend Masterclass, but you don't need it to join: you start with the complete codebase, and the first module recaps all the patterns it uses.

Stay in your environment. Use your favorite tools.

Real-life projects don't happen in the browser. We let you stay with your favorite tools. VS Code, GoLand, Vim, Emacs? It's up to you.

You want to write all code by hand? Or use Claude, Copilot or Cursor? Our training is compatible with AI-assisted coding.

Our platform guides you through the training. It's a unique experience that helps you learn the fastest way possible: by doing. You won't learn this way anywhere else.

You can solve the exercises at any time that suits you best. You can start the training now, in a week, or a year.

Real reviews of our trainings

See what professional developers say about our trainings.

Review avatar

Nicolás Palumbo

Senior Software Engineer, New Relic · Verified buyer

This training goes in depth on a practical project using DDD, explaining as much theory as required to understand what's coming next. The outcome is a neat multi-module codebase that you build on your own with guidance, a working domain model with aggregates, entities and value objects that work well for the domain under question.

The course it's not easy peasy, it requires some time, but you definitely come out learning something.

Review avatar

Petr Vitek

Developer
Previous training verified buyer

Great hands-on course that immediately puts the theory into practical example.

Small focused programming tasks and one longer bigger project that is built through the whole course is great for having isolated examples of the concepts and also their place in overall architecture which is often missing in courses/tutorials.

And as a bonus contains clever tool that allows you to work on the examples in any IDE you prefer AND does run robust tests that make sure the code works properly.

Review avatar

Damian Trzepała

Software Development Engineer
Previous training verified buyer

The CLI tool they've got for hands-on exercises is a game-changer. The CLI tool functions like an interactive debugger, giving immediate feedback and validation as you work through coding exercises. I'm looking forward to using what I learned directly in my job.

The Discord community is also a big win. It's not every day you get to chat directly with the people who made the course. They're super helpful and quick to answer any questions. Also, they continuously take feedback and improve the course.

Review avatar

Dima Kotik

Programmer
Previous training verified buyer

The best technical course I have ever bought! It teaches and demonstrates practical engineering excellence that will level you up and leave you with much to think about.

Review avatar

Tobias Andersson

Site Reliability Engineer
Previous training verified buyer

What is often missing when learning new things is interactivity along with easy explanations for complex technical terms.

This course has all the elements that made it an incredible course, it is interesting, challenging but above all incredibly educational.

Review avatar

JP Fontenele

Senior SWE
Previous training verified buyer
The hands on training is perfect for engagement and drilling down the concepts of event driven. I've done video training before, and don't get me wrong it's certainly possible to learn with them, but comparing to this approach is certainly a step up in the learning process.
Review avatar

Vladimir Stankovic

Engineering Manager, Code Reflect
Previous training verified buyer

This course is absolutely amazing! The course made complex concepts seem incredibly simple, and the explanations were crystal clear. I couldn't have asked for a better learning experience. Highly recommended!

Review avatar

Mohamed Mirghani

Senior Backend Engineer, Tweeq
Previous training verified buyer

The hands-on approach was exactly what I needed it kept me truly engaged and accountable. Unlike passive video courses I could not just breeze through it without understanding the material. The practical exercises forced me to apply what I learned right away.

I highly recommend this training to anyone interested in learning Golang quickly and effectively.

Review avatar

Michal Kozák

SRE, Keboola
Previous training verified buyer

Practice beats theory! I have read some books to get me up to speed with Go, but there's nothing better than actually doing it. The AI mentor is goat, helped me get unstuck numerous times.

Review avatar

Muhammad Ilham Hidayat

Software Engineer
Previous training verified buyer

Before I joined Go Event-Driven course from ThreeDotsLabs, I already used their watermill package for event driven applications.

By joining Go Event-Driven course, I realized that I only scratched the surface for watermill package and event driven applications in Go.

I enjoyed and learned a lot from this course.

Review avatar

Kacper Siuda

DevOps
Previous training verified buyer

The Golang Event-Driven training was a highly beneficial experience, especially due to its hands-on approach, which facilitated a deeper understanding and retention of core concepts. Applying the acquired knowledge has brought a new dimension of efficiency and scalability to my daily job tasks.

Review avatar

Viacheslav Ostrovskii

Software developer
Previous training verified buyer

That is a great idea to wrap up all information about event-driven systems in Go and put it in a training with a convenient platform. I must admit quality of training parts, there are no boring videos just best practices, real-world examples and joy of coding.

The Three Dots Labs team created a great product to improve yourself in short period of time. Thanks a ton!

Review avatar

Bastiaan Breemer

Low code developer
Previous training verified buyer

Good training for understanding event driven design of applications, with the use of Watermill. It's great that you're able to do this training in your own coding environment, sometimes the error messages are a bit cryptic but for the most part it's easy to understand. From the way they first make you do an exercise and then implement that into a project makes you think about where it would fit inside a real implementation.

Review avatar

Cristo Sun

Senior developer
Previous training verified buyer

I really love this course! Unlike books or blogs, you can actually code step by step in this course, which gives you a much more solid understanding. Plus, event-driven programming is going to be the next big thing in the future as software becomes more complex. So, this course is totally worth it for you.

Review avatar

Thanh

Fullstack Developer
Previous training verified buyer

The training is so great to help me understand concepts of event-driven architecture, and technic to apply its to my work. It's included the solutions for my problem when design system with serverless framework like nextjs, trpc. I find like this training so much. Thank you for all awesome work!

Review avatar

Gyanendra Singh

Full stack Developer
Previous training verified buyer

Amazing, it's just amazing, the course content is really good and the difficulty is just right, that don't hold your hand through the training neither do they completely leave you, it's in between and perfect combination of both the things.

Review avatar

Luís Pinto

Backend Engineer
Previous training verified buyer

The content was really well put together, everything builds upon what we are learning along the way and the approach of the small projects where all the knowledge is tied up together works really well!

This was a really nice course - I'd say that's a 10/10 in terms of value for money. I'm eager to start the next course from Three Dots Labs as soon as it's available!

Review avatar

Fernando Munoz

Developer & Tech Chief, Microplan
Previous training verified buyer

I love this course! I was planning to learn Go but I find it very difficult since there was no single source where I could learn about Project structure... Base concepts of Go... Conventions... Concurrency...

All this in a fun and easy way! I think I came to the right place and I would recommend this course to anyone who would like to learn Go! And improve their skills as a Dev.

Review avatar

Sebastian Will

Software Developer, Freelancer
Previous training verified buyer

I managed to break the training into smaller sessions to get a good overview about Go during my holidays. The individual topics contain concise information about the language's specifics and can be used as a short and handy reference later on.

The integration into VS code is working great; all in all it's a no fuss, hands-on primer that gets you up to speed.

Review avatar

Daniel Fenert

Architect, G2A.com
Previous training verified buyer

Very good training that systemizes essential Go knowledge with simple exercises. Good value for money.

Review avatar

Bilal Islam

Senior Developer, Freelancer
Previous training verified buyer

The Three Dots Labs team created a great training for all Go lovers. I had fun while I was guided to the next step every module. That is to say, I absolutely recommend it to everyone.

Review avatar

Andrés Uris

Software Developer, NaranjaX
Previous training verified buyer

Great training to learn and practice go fundamentals

I have enjoyed and learned a lot from this training. I feel more confident with my knowledge about programming Go and now I have a great foundation that will help me a lot in my journey with Go

Review avatar

Juan Lasso

Del Valle University
Previous training verified buyer

This is one of the best programming courses online and Threedots way of teaching is awesome. The course is easy to setup and the exercises are ready to go!

Review avatar

Yehor Masalitin

Senior Software Engineer
Previous training verified buyer

I'm a Senior Software Engineer with experience in Java / Kotlin / Python / JS but I have never tried Go and didn't want to learn it the regular way as it was too boring to go over again of "Imagine that the variable is a box...".

This course was amazing for me, I just learned what is DIFFERENT in Go from all the other languages I worked with. Loved it. Highly recommended.

Review avatar

Anirudh Nitin Bakare

Student, Northeastern University
Previous training verified buyer

The course is well curated to build enough confidence in you to start that next go project. It abstracts the concepts just enough for any developer to understand grasp the syntax and usage. Enjoyed the course.

Review avatar

Kirill

Senior Python Backend Developer, Compel
Previous training verified buyer

This course will be helpful for anyone who wants to quickly learn the basics of Golang. It's also great if you need to figure things out fast and solve a work-related problem using Go. The exercises are well-designed and very similar to real backend tasks you might face when working with Go. Overall, if you're just looking to get started with Go, this course is a solid entry point.

Review avatar

Geovanny Mendoza

Software Engineer, Geovannycode
Previous training verified buyer

The course exceeded my expectations. The combination of theory and practice helped me to acquire new skills and improve my job performance. I highly recommend this training to anyone looking to expand their knowledge and skills in the field.

Dave Chapman

Engineering Lead, Epic Games
Previous training verified buyer

Really well thought out hands-on approach to learning Go. Epic use Go quite a bit so it has been useful for me to learn the fundamentals. Highly recommend the training!

Max Wolffe

Sr. Software Engineer, Databricks
Previous training verified buyer

Go In One Evening is an incredible way to quickly get a working knowledge of Go!

The training is interactive and follows some excellent teaching patterns (spaced repetition, interleaving, etc). Highly recommend.

Freddy Fostvedt

Machine Learning Systems Engineer, Atlassian
Previous training verified buyer

I completed the go in one evening course. It's highly integrated into the IDE and terminal and course progress is easy, fun and fast. The course is comprehensive on basics, very hands-on and problem solving-oriented. I'd highly recommend this to anyone wanting to build experience with the basics of go.

title

Created by

Miłosz Smółka & Robert Laszczak

Three Dots Labs logo Three Dots Labs founders

Over the last couple of years, we gained the trust of the Go community by sharing what we know. We are the authors of the Three Dots Labs blog (270K+ unique visitors per year), and our e‑book: Go With The Domain (60K+ downloads).

We are also authors of the Watermill library (9,888 ★ on GitHub), the most popular Go library for building event-driven and message-driven applications.

We worked in many fields, including infrastructure, complex and global financial domains, healthcare, and security. Along the way, we've built a few startups and led multiple teams. It gave us a broad perspective on software development across different organizations.

We've been building projects together for over 17 years. In 2024, we switched to working full-time on training for experienced software engineers.

When we meet in our free time, we like to cook and eat some steaks and burgers.

So far, 7,400+ Go developers have trusted us with their learning.

Waiting list

The cohort isn't open yet.
Get a head start for free.

The Domain Engineer opens Autumn 2026, for two weeks. Leave your email and you get, today:

  • Go with the Domain, our free ebook: 221 pages on Go backends that stay easy to change, with a real open-source project you can run. Agents imitate the code they find: tangled domain logic multiplies with every prompt. The ebook is the theory behind The Domain Engineer: the DDD, Clean Architecture, and CQRS you'll practice in the training. Downloaded by 60,000+ developers.
  • The email mini-course: 15 short lessons on the patterns behind production Go, one a week. Clean Architecture in Go, the repository pattern, introducing CQRS, combining it all with DDD.
  • First to know when the next cohort opens. Sales run twice a year, for two weeks each. The list gets you the date in time for the next one, not six months later.
Go with the Domain ebook cover

60,000+ downloads