Skip to main content
Starts in Next edition:

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.
Join now

If you change your mind, you can return it up to 30 days after the cohort starts.

Avatar 0Avatar 1Avatar 2Avatar 3Avatar 4Avatar 5Avatar 6Avatar 7Avatar 8
πŸ”₯ 799 developers are already on board
Created by
8,000+ Go devs trainedWatermill 9,924 β˜…Wild Workouts Go DDD example 6,478 β˜…270K+ 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. You need them whether you build by hand or with your coding agent.

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 build the important parts.

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.

you@home: ~/trainings/the-domain-engineer

[…] What needs to be implemented in this exercise?

New exercise: settlements needs its own Order type, separate from the orders-side one since they're different bounded contexts. […]

3. Getters for all nine fields. […]

The settlements Order gets stored once and never changes state. Where should it live?

  • Put it in domain/ next to IBAN 
    // backend/settlements/domain/order.go
package domain
type Order struct { orderUUID OrderUUID; /* ... */ }
  • Keep it in app/models/ next to LegalEntity and Partner 
    // backend/settlements/app/models/order.go
package models
type Order struct { orderUUID OrderUUID; /* ... */ }

Which one?

Keep it in app/models, next to LegalEntity and Partner. It doesn't have real invariants or state transitions yet, so putting it in domain/ would just give us getters and setters with no payoff, that's the anemic domain model trap. We can promote it later if that changes.

Agreed. You named both parts of it: no invariants to protect today, and the option to promote it later. The Order here is just a record of what was ordered, how much it cost, and when. […]

[…] ubiquitous language is scoped to its bounded context. Types can move between domain/ and app/models/ as their responsibilities change.

Works with your AI coding workflow. Your agent won't one-shot the exercise: it asks what you want to build and has you make the crucial decisions first.

Recorded in a real exercise, with an AI playing the learner. Trimmed for length.

We've been shipping production systems for 18 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. ~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.

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.

Become The Domain Engineer for:

$499
Join now
  • Start today. Warmup exercises open the moment you buy. The rest opens with the cohort.
  • Lowest price, guaranteed. The price goes up after every sale. We never run promotions or discount codes.
  • Complete starter codebase included. You begin with the full project from our Go Backend Masterclass and a recap of its patterns. No prerequisites needed.
  • Lifetime access with free updates. Pay once, keep it forever. Buyers of Go Event-Driven got the full 2.0 overhaul two years later at no extra cost.
  • AI-powered mentor when you get stuck. An AI tutor that knows the codebase and exercises. Ask it anything, anytime.
  • Zero risk. Full refund up to 30 days after the cohort starts. No questions asked.
  • Certificate of completion. If someone has this cert, they built the thing. Add it to your LinkedIn or show your employer.
  • Use your training budget. Your company probably has budget for this. Buy now, get reimbursed later. We issue invoices.

We are starting in

0days
0hours
0min
0sec

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.

Type the code yourself or work with your coding agent. The training is built to work with agents, and the tests verify the result either way.

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

Pavlo Korchagin

Lead Software Engineer · Verified buyer

Having over 25 years of backend experience, I am extremely selective about training, but as this was my third course with Three Dots Labs, I knew I was in good hands. The Domain Engineer course delivers an outstanding learning path, made even better by their seamless coding platform and knowledge index.

The real value for me came down to how it refined my approach to structuring data, system layouts, and architecture. More importantly, it gave me a strong foundational framework that I can now use to guide and mentor junior developers at work.

Review avatar

Hieu Tran

Front-end Team Leader, Smilegate Vietnam · Verified buyer

An exceptional course on DDD! The architecture feels as powerful and elegant as Zend Framework 2, offering a fantastic blueprint for building cleaner and more adaptable features.

Crucially, this clean structure makes the project much easier to maintain later on, especially when leveraging AI agents for development. It completely matched what I was looking for!

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,924 β˜… 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 18 years.

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

So far, 8,000+ Go developers have trusted us with their learning.

What developers say about us on Reddit

Our blog posts and e-book are considered classics in the Go Domain-Driven Design community.

Reddit comment praising Three Dots blog articles
Reddit discussion thread about Go with DDD ebook
Reddit testimonial about threedotlabs material

We help engineers grow up to the VP level. At least that's what they tell us.

Email testimonial

Our Go example project is the most starred Go domain-driven project on GitHub.

GitHub repository stars

That's the impact of our free content.
Imagine what the full training will do.

I'm in!

Become The Domain Engineer for:

$499
Join now
  • Start today. Warmup exercises open the moment you buy. The rest opens with the cohort.
  • Lowest price, guaranteed. The price goes up after every sale. We never run promotions or discount codes.
  • Complete starter codebase included. You begin with the full project from our Go Backend Masterclass and a recap of its patterns. No prerequisites needed.
  • Lifetime access with free updates. Pay once, keep it forever. Buyers of Go Event-Driven got the full 2.0 overhaul two years later at no extra cost.
  • AI-powered mentor when you get stuck. An AI tutor that knows the codebase and exercises. Ask it anything, anytime.
  • Zero risk. Full refund up to 30 days after the cohort starts. No questions asked.
  • Certificate of completion. If someone has this cert, they built the thing. Add it to your LinkedIn or show your employer.
  • Use your training budget. Your company probably has budget for this. Buy now, get reimbursed later. We issue invoices.

We are starting in

0days
0hours
0min
0sec
We are indie

Built by Engineers, for Engineers

We're a bootstrapped company building the training we wish existed. We answer to students, not investors.
By buying this training, you help us create more high-quality learning materials the community needs.

Still not sure?

We're developers ourselves, and we carefully pick our paid tools. We want you to be sure you've made a good career investment by buying our training.

If you change your mind, you can return it up to 30 days after the cohort starts. Even if you finish the training within 30 days and don't like it. No questions asked. We'll just return your money.

Join now!
Gopher of trust

FAQ

You need basic Go knowledge: syntax, functions, structs, interfaces, and packages. If you can write a simple HTTP handler and work with a database in Go, you're ready.

You don't need any DDD or architecture experience. The training teaches all patterns from scratch, and tools like Echo, sqlc, and testify are introduced as you go. If you already know DDD from other languages, the training focuses on idiomatic Go implementation, not just theory.

Early exercises are heavily guided with detailed hints. As you progress, you get more room to build things your way. Every exercise still includes solution snippets, so you won't get stuck.

Don't know Go yet? Check out our Go In One Evening training. It covers everything you need to get started.

We'd love to do that, but it's not possible as long as there are 24 hours in a day.

Instead, you get an AI mentor that knows the codebase and every exercise, plus support in a private Discord channel. You'll receive access to private channels after joining the training.

A real, big one. You start from the complete codebase of our Go Backend Masterclass, so you don't need that training, and grow it into a global food delivery platform with billing, settlements, and payouts. The tests verify every step.

Most exercises take about 10 minutes, so you can make progress on a busy day. It fits around a full-time job.

The cohort runs for 3 weeks, but going with its pace is optional. You have lifetime access, so you can also go through the exercises on your own schedule.

Yes. The training has native support for coding agents, and exercises ship with agent instructions. You can also write every line yourself. Both paths end at the same place: tests verifying that your solution works.

Most of us don't start from a blank canvas. We keep systems running that customers rely on, built on decisions someone made years ago. Agents make it cheap to revisit those decisions, and just as easy to get them wrong.

You can't review what you don't understand. Your agent will write the endpoint. It will also decide what to put in the domain layer, and it won't tell you when it got it wrong. You learn to catch that by making those calls yourself and seeing what breaks.

We're doing our best to make you enjoy the training. But it would be arrogant to think we can satisfy everyone.

You can return it up to 30 days after the cohort starts, even if you finish everything first. That makes the whole training your trial. No reason required, though we'd love to hear it.

We're confident the content delivers, so we can offer such a flexible policy and still have a super low refund rate.

We keep rules like these for our own agents too, and most of the time they work.

But knowing how to architect code, especially in the complex cases, is what makes you notice when the agent doesn't follow a rule. Then someone has to decide whether to bend the rule or keep it. That takes the understanding this training builds. It also makes your rules better, because you know why each one is there.

Tutorials and AI chats explain how it works. The training makes you build it on a real project, by hand or with your coding agent. The tests tell you in seconds whether you got it right.

Agents are one more level of abstraction, like an ORM on top of SQL. You can use an ORM without knowing SQL. But knowing SQL is what makes you good with an ORM, and knowing how a backend works is what makes you good with an agent.

Fair question, since every guru says something different. We've been shipping production Go since 2017, across financial systems, healthcare, and infrastructure. We wrote Watermill (9,924 stars on GitHub) and the Three Dots Labs blog (270K+ readers a year).

More importantly, the training teaches tradeoffs, not dogma. You'll see where a pattern pays off and where it's overkill.

Not if you know when a pattern is worth it. We've watched overengineering kill velocity on teams we led: two-day features turning into two-week refactors. A good part of our blog argues against exactly that.

Each module starts with the smallest thing that works, then shows where a pattern starts paying off. You'll know when complexity is worth it and when to skip it.

The cohort starts when the sale ends, and new modules open every week from then on. Warmup exercises open the moment you buy, so you can start right away.

You will have lifetime access to the training content, including all future content updates.

You can implement the training only in Go, but the patterns you'll learn are universal and can be applied in any programming language.

We're considering adding support for other programming languages in the future. If you purchase during this sale, you will receive access to all future updates, including new programming languages.

If approval won't come before the sale ends, buy it yourself now. Once your company approves, email us at contact@threedotslabs.com and we'll take care of the rest: your company pays us, and we refund you, with a new invoice if you need one. No approval? The 30-day guarantee still applies.

For a VAT invoice, add your Tax ID at checkout. To pay by wire transfer in EUR, USD or GBP, email contact@threedotslabs.com with your company details and the number of licenses.

One license is for one person. Buying for your team? Volume discounts apply automatically in the cart: 10% from 10 licenses, 20% from 20, and 30% from 30.

If you have any other questions, please contact us at contact@threedotslabs.com.

Secure your spot
Sale ends in
Join now