Next edition: Autumn 2026

Become a confident
Go backend engineer

The kind who speaks up in design discussions, isn't afraid of the post-mortem, and knows how to structure a new project.
You get there by building a real production backend, with fast feedback at every step.

1-minute setup. Exercises fit in 10 minutes a day.

Your IDE, your tools. The CLI handles setup and boilerplate.

A safe environment. No deadlines and no production risk.

Never stuck. An AI mentor that knows the codebase, plus the authors on Discord.

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

🔥 793 developers are already on board

Created by

7,400+ Go devs trainedWatermill 9,887 ★Wild Workouts Go DDD example 6,449 ★270K+ yearly blog readers

Engineers learning with us work at

From the engineers who went through this training:

I wasn't sure if the course would be worth the price, but it absolutely was. The content is practical, high-quality, and solves real problems you'll face in production systems.

The biggest benefit for me is having a clear approach to structuring backend applications. I've already applied the ideas at work with great results.

Thanh Dao

Software Engineer, Airtasker · Verified buyer

You can't learn this
from tutorials

So you finished the Go tour and built a TODO app. It feels great, but then you open the codebase at work, and nothing looks familiar.

Every tutorial teaches a different project structure. One YouTube guru swears by Clean Architecture, and another calls it overengineering. (People on Reddit say both are wrong.)

And now, AI makes it worse. It writes code faster than you can read it. If something breaks at 2 AM, "the agent wrote it" won't cut it at the post-mortem.

Enough of the theory and vibe coding. You need to build a real system, make mistakes, and get feedback to know how to improve.

There's no safe place to practice.
So we built one.

The only way to learn backend skills is to make decisions and see what breaks.
But what happens when you make a mistake?

The project you practice on

May not fit the patterns you want to learn. You either force them or never try.

Built for exactly these patterns. You see where they fit.

You use a pattern wrong

Nobody notices for weeks. Then you miss the deadline, and the project is now “at risk”.

Tests catch it in 0.9s and tell you what happened. A wrong status code, a missing transaction, or a broken contract. Fix it and run them again.

Something breaks

Production goes down. You're included in the post-mortem, hoping it won't end with finger-pointing.

No production to take down. The worst that breaks is a test on our servers.

The design discussions

Someone pushes back, and you give up. You're never sure enough to argue.

You know why each pattern fits, and when it doesn't. You can explain it clearly, and the team respects you.

It all adds up

The promotion talk moves to next year. If you're less lucky, your name lands on a different list.

You've tried a few different approaches to a problem, and they stay with you. You internalize what you're doing instead of reading theory.

At work, you play it safe.

In the training, you experiment.

Move fast and break things. Here, not at work.

You practice on a production-grade system built for exactly this. You get all of the experience with none of the risk.

The next cohort opens Autumn 2026. Join the waiting list and start with the free ebook today.

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

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

you@home: ~/trainings/backend-masterclass

$ tdl training run

project/backend/orders/adapters/db/dbmodels/read_models.sql.go | 23 +++++++-

project/backend/orders/adapters/db/queries/read_models.sql | 14 +++++-

project/backend/orders/adapters/db/read_model.go | 7 ++-

project/backend/orders/api/http/client/client.gen.go | 72 +++++++++++++++++++++++---

project/backend/orders/api/http/openapi.gen.go | 45 +++++++++++++++-

5 files changed, 145 insertions(+), 16 deletions(-)

Exercise ready.

Press ENTER to run your solution or q to quit

--------

✓ Setup

✓ Filter by restaurant name works

✓ Order by price_asc returns cheapest first

✗ Order by price_desc returns most expensive first

With order_by=price_desc, expected most expensive item first (Premium Steak), got Budget Burger

✗ Ordering works without restaurant filter

Items not sorted by price_asc: item 2 (Classic Taco, 5) should not come after item 1 (Premium Steak, 45)

--------

FAIL

Press ENTER to run solution again or q to quit

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

you@home: ~/trainings/backend-masterclass

$ tdl training run

project/backend/orders/adapters/db/dbmodels/read_models.sql.go | 23 +++++++-

project/backend/orders/adapters/db/queries/read_models.sql | 14 +++++-

project/backend/orders/adapters/db/read_model.go | 7 ++-

project/backend/orders/api/http/client/client.gen.go | 72 +++++++++++++++++++++++---

project/backend/orders/api/http/openapi.gen.go | 45 +++++++++++++++-

5 files changed, 145 insertions(+), 16 deletions(-)

Exercise ready.

Press ENTER to run your solution or q to quit

--------

✓ Setup

✓ Filter by restaurant name works

✓ Order by price_asc returns cheapest first

✓ Order by price_desc returns most expensive first

✓ Ordering works without restaurant filter

--------

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/backend-masterclass/project] - orders.go

project

backend

cmd

common

delivery

orders

adapters

api

app

courier.go

customer.go

orders.go

restaurant.go

service.go

module.go

tests

Dockerfile

reflex.conf

svc.go

docker-compose.yaml

go.mod

go.sum

Taskfile.yml

orders.gocourier.goservice.go

414func (s *Service) AcceptOrder(

415 ctx context.Context,

416 restaurantUUID RestaurantUUID,

417 orderUUID OrderUUID,

418) error {

419 return s.orderRepository.UpdateOrder(

420 ctx,

421 orderUUID,

422 func(ctx context.Context, order Order) (Order, error) {

423 if err := checkRestaurantMatch(order.RestaurantUUID, restaurantUUID); err != nil {

424 return Order{}, err

425 }

426

427 if order.RestaurantConfirmedAt != nil {

428 log.FromContext(ctx).With("order_uuid", orderUUID).Warn("Order already confirmed")

429 return order, nil

430 }

431 order.RestaurantConfirmedAt = common.ToPtr(time.Now())

432

433 return order, nil

434 },

435 )

436}

backend/orders/app/orders.goLFUTF-8Tab

A codebase you could see at your job. Multiple modules, HTTP handlers, Postgres repositories, generated API clients. A modular monolith built the way we build production systems. The boring parts are on us. You write the important code.

Go Backend Masterclass 08-advanced-repositories - 04-onboard-restaurant-endpoint

Onboard Restaurant Endpoint

With the repository and application service in place, let's now expose an HTTP endpoint for the frontend to use.

The new HTTP handler (OnboardRestaurant) follows the same pattern as RegisterCustomer, so most of this should feel familiar. The new part is mapping a collection of menu items from the request body to application types.

The Handler

You need to add the OnboardRestaurant handler in backend/orders/api/http/handler.go. It should map the OpenAPI request types to application types and call h.service.OnboardRestaurant.

It's similar to the RegisterCustomer handler with one difference: you need to map request.Body.MenuItems to []app.MenuItem in a loop. RegisterCustomer has no equivalent collection, so you can't copy this part directly.

The restaurant UUID comes from request.RestaurantUuid, a path parameter. You'll need a float64() cast for the Ordering field. Convert the address to the application type the same way you did for RegisterCustomer.

The OpenAPI spec includes an Operator-UUID header in the request. It identifies the person from the operations team who performs the onboarding.

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

We've been shipping production systems for 17 years. Go Backend Masterclass lets you skip the mistakes and dead ends we already made.

Everything you get

Get the complete path from Go basics to a production-grade backend.

The learning path

Each module builds on the last one. Perfect mix of theory and practice.

A real production project

A food delivery backend. ~8,500 lines of Go you own plus the code-generated parts.

Guided exercises

Write a bit of code and get fast feedback. Move smoothly through all the modules.

A CLI that does the boring parts

Boilerplate is on us. You write the interesting code.

Also included, at no extra cost

AI mentor, day and night

Knows every exercise and the whole codebase.

The authors on Discord

Any questions? Ask the people who built it.

Certificate of completion

Proof of your verified hands-on work.

Lifetime access + free updates

Pay once, get all updates for free. New modules included.

A cohort to start with

Stay motivated and keep momentum with the group.

30-day money-back guarantee

No questions asked.

All of it opens with the next cohort, Autumn 2026.

Real reviews from Go Backend Masterclass

From engineers who went through the training.

Sergii Shapoval

Senior Software Engineer, ROClub · Verified buyer

Before this training, I had experience with Go, but I still had blind spots around architecture, setup, and how to build a backend in a way that stays maintainable as requirements change. I could make things work, but I did not always feel confident that the approach would scale well for a team or a real product.
What made this course valuable was not just the information itself, but the way it was structured. It gave me a solid, extendable foundation with clear patterns, practical setup decisions, and explanations of why those choices matter.
Recommended this project setup to my new teammates, and they like it as well.

Pavlo Korchagin

IT Team Lead · Verified buyer

This is my second course with Three Dots Labs, and once again, they did not disappoint. The learning flow is fantastic, combining a highly usable academy platform, complete with excellent knowledge graphs, with a seamless local tool that guides you through hands-on exercises.
As a developer with over 25 years of experience, I found myself completely aligning with Robert and Miłosz's philosophy on code structuring and system architecture. The Backend Masterclass also served as a perfect prelude to the Domain Engineer course, which I am taking now.
Thank you, guys, for the incredible work you are doing!

Jorge Alfaro

Backend Engineer, VGV · Verified buyer

Although I took part in the beta version, the content is absolutely crucial. I've been following you for a long time: your posts, e-book, and previous course all took my career to the next level.
This course introduces patterns that initially seem daunting, but you break them down so clearly. I've already started applying them in both my job and personal projects.

Alexis Salgado

Software Engineer, DEVBUG · Verified buyer

It is a good course, it helped me to know things that I did not know about structuring a project, in addition to some other tips that I did not know about database migrations and patterns.

Aatmaram Tamhanekar

SDE-III, Kissht · Verified buyer

The Backend Masterclass is a structural recap for someone who has already built Go systems from scratch, covering modular monoliths and project-level error handling.
For beginners who have never structured a Go repository from scratch, it can be very helpful and confidence-building. Some parts feel familiar to experienced developers, but still serve as good reinforcement.

Ed Huang

AI Engineer, MYI · Verified buyer

This course gave me lots of help and advice make me have real improvements on my daily work. Thanks a lot this is pretty helpful.

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!

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.

JP Fontenele

Senior SWE
Previous training verified buyer

The hands on training is perfect for engagement and drilling down the concepts. 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.

Max Wolffe

Sr. Software Engineer, Databricks
Previous training verified buyer

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.

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.

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...
I think I came to the right place and I would recommend this course to anyone!

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.

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.

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!

Kacper Siuda

DevOps
Previous training verified buyer

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.

Bastiaan Breemer

Low code developer
Previous training verified buyer

It's great that you're able to do this training in your own coding environment. 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.

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!
I'd say that's a 10/10 in terms of value for money.

Andrés Uris

Software Developer, NaranjaX
Previous training verified buyer

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

Sebastian Will

Software Developer, Freelancer
Previous training verified buyer

I managed to break the training into smaller sessions during my holidays. 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.

Created by

Miłosz Smółka & Robert Laszczak

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,887 ★ 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.

Go Backend Masterclass 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 will get any endpoint working. But keeping a hundred of them under control takes structure, and that's what the ebook covers. You'll learn about repositories, Clean Architecture, and tests, and practice all three later in the training. Downloaded by 60,000+ developers.
The email mini-course: 15 short lessons on the patterns behind production Go, one a week. Repository pattern, database transactions, integration tests, Clean Architecture.
First to know when the next cohort opens.

60,000+ downloads

Become a confidentGo backend engineer

You can't learn thisfrom tutorials

The learning path

A real production project

Guided exercises

A CLI that does the boring parts

AI mentor, day and night

The authors on Discord

Certificate of completion

Lifetime access + free updates

A cohort to start with

30-day money-back guarantee

Miłosz Smółka & Robert Laszczak

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

Become a confident
Go backend engineer

You can't learn this
from tutorials

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