Skip to main content
Starts in

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. Solo or with your AI agent.
A safe environment. No deadlines and no production risk.
Never stuck. An AI mentor that knows the codebase, plus the authors on Discord.
Join the cohort

30-day money-back guarantee, even if you finish everything.

Avatar 0Avatar 1Avatar 2Avatar 3Avatar 4Avatar 5Avatar 6Avatar 7Avatar 8
🔥 861 developers are already on board
Created by
7,900+ Go devs trainedWatermill 9,912 ★Wild Workouts Go DDD example 6,470 ★270K+ yearly blog readers

Engineers learning with us work at

Atlassian1PasswordAnchorage Digital
LufthansaDatabricksQualcomm
SinchHadrianDiscovery
ZscalerEricssonNord Security
KongSumUpVinted
GrabEpic Games

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

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. Agents moved us one level of abstraction up, the way ORMs did for SQL. You can use an ORM without knowing SQL, until the first slow query. You can ship with an agent the same way, until something breaks at 2 AM and "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.

Join the cohort

30-day money-back guarantee, even if you finish everything.

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

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.

HTTP Request PUT /restaurant/onboard OnboardRestaurant Handler app.Service .OnboardRestaurant() RestaurantRepository .UpsertRestaurant() PostgreSQL map request
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.

you@home: ~/trainings/backend-masterclass

What needs to be implemented in this exercise?

[Pasted exercise content]

On a real project, you'd read the requirements and tell the AI what to build. That's what we're practicing here. If you want to learn to direct AI, not just copy-paste into it, read the exercise and describe what needs to happen.

three courier endpoints this time: accept-delivery, report-pickup and report-delivery […] accept: 409 already-accepted if the order already has a courier, and a courier can only take orders in their own city […] if both pass, assign the courier and set CourierAcceptedAt […]

One decision before I write the code. CourierAcceptDelivery compares the order's delivery city with the courier's city. Where do we read the courier's city?

  • A: Before UpdateOrder, outside the transaction 
    courierCity, err := s.courierRepository.GetCourierCity(ctx, courierUUID)
return s.orderRepository.UpdateOrder(ctx, orderUUID,
    func(ctx context.Context, order Order) (Order, error) {
        // compare order.DeliveryAddress.City with courierCity
  • B: In a dedicated repository method, in the same transaction as the order 
    AssignCourierToOrder(ctx context.Context, orderUUID OrderUUID, courierUUID CourierUUID,
    validateFn func(ctx context.Context, order Order, courierCity string) error) error

Which one do you want?

a, before UpdateOrder. the page says the city only gets set at registration and never changes after that, so nothing can change it between the read and the update

Agreed. The city is set once at registration, so reading it before the transaction is safe. […]

Insight: If couriers could change their city, reading it outside the transaction wouldn't be safe. […]

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.

Illustration: how your agent handles this decision in one of the exercises.

We've been shipping production systems for 18 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 with the modules, tests, and tooling of a real company codebase.

Guided exercises

Small steps with feedback in seconds. You always know what to do next.

A CLI that does the boring parts

Boilerplate is on us. You build the interesting parts.

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.

For less than a conference ticket, you leave with a system you built and skills you keep.

Join the cohort

Become a confident Go backend engineer for:

$888

The cohort starts in

0days
0hours
0min
0sec
Join the cohort

30-day money-back guarantee, even if you finish everything.

  • Start today. Warmup exercises open the moment you buy. The rest opens with the cohort.
  • Zero risk. Full refund up to 30 days after the cohort starts. No questions asked, even if you finished everything.
  • Lowest price, guaranteed. The price goes up after every sale. We never run promotions or discount codes.
  • Lifetime access with free updates. Pay once, keep it forever.
  • AI mentor included. It knows every exercise and the whole codebase. Ask it anything, anytime.
  • Certificate of completion. It proves you built a working backend, not that you watched videos.
  • Use your training budget. Your company probably has budget for this. Buy now, get reimbursed later. We issue invoices.

The loop that makes it safe

You get feedback in seconds, not in production. This is the loop you'll work with:

1

Run one command

The CLI sets up the whole project. It takes about a minute, in your terminal.

$ tdl training init backend
2

Build in your IDE

VS Code, GoLand, or Vim.

3

Get verified in seconds

Tests check your solution. Green or red instead of “looks good to me”.

✓ all tests passed (1.2s)
↺ Red? Fix it and run again. As many times as you need, for free.
4

Never stay stuck

The AI mentor knows the codebase, and the authors answer on Discord.

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.

Join the cohort

What do graduates like about our platform?

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.

Damian Trzepała

Damian Trzepała

Software Development Engineer
Previous training verified buyer

What will you learn?

Each exercise is a focused, small change that takes about 10 minutes.

Together, we'll build a food delivery platform backend from scratch. You'll set up the project, design APIs, wire the database, and connect modules into a working system.

Go Backend Masterclass 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
  • Structure a modular monolith so teams can work independently from day one
  • Automate local development with Docker Compose and Taskfile
  • Set up structured logging with slog for production-ready observability
What you will build
  • Set up a local dev environment with Docker Compose
  • Configure a modular monolith project scaffold
  • Add structured logging across services
What you will learn
  • Design APIs contract-first so frontend and backend teams can work in parallel
  • Generate Go server code from OpenAPI specs with oapi-codegen
  • Map OpenAPI schemas to custom Go types for type safety beyond primitives
What you will build
  • Define an API contract in OpenAPI
  • Generate server stubs and types from the spec
  • Add type-safe domain UUIDs mapped from OpenAPI schemas
What you will learn
  • Manage database schema changes with go-migrate migrations
  • Generate type-safe Go code from SQL queries with sqlc
  • Catch query bugs at compile time instead of at runtime
What you will build
  • Create and run database migrations
  • Write SQL queries and generate Go code with sqlc
  • Insert and query data using generated, type-safe code
What you will learn
  • Decouple database logic from HTTP handlers so each can change independently
  • Write integration tests against a real PostgreSQL instance
  • Use interface-based dependency injection to swap implementations
What you will build
  • Implement a repository that hides database details behind an interface
  • Write integration tests with real PostgreSQL
  • Wire the repository into handlers using dependency injection
What you will learn
  • Build an application layer independent of HTTP, gRPC, or any transport
  • Define domain entities that multiple entry points can share
  • Enforce compile-time safety with dedicated UUID types using struct embedding
What you will build
  • Create an application service with transport-independent logic
  • Define domain entities separate from database models
  • Add type-safe UUIDs with struct embedding
What you will learn
  • Design transport-agnostic errors using slugs that map cleanly to HTTP and gRPC
  • Generate HTTP clients from OpenAPI specs for reliable API testing
  • Write component tests that cover the full request lifecycle with real infrastructure
What you will build
  • Implement error handling with slug-based error types
  • Generate an API client from your OpenAPI spec
  • Write component tests that hit real databases and HTTP endpoints
What you will learn
  • Implement idempotent upserts that handle concurrent writes gracefully
  • Use the transactional callback pattern for complex multi-step business logic
  • Share types across modules without creating tight coupling
What you will build
  • Build an upsert with ON CONFLICT for idempotent writes
  • Implement updateFn callbacks for transactional business logic
  • Wire multi-entity endpoints that span module boundaries
What you will learn
  • Build read models with SQL JOINs that avoid the N+1 query problem
  • Add dynamic filtering and sorting to list endpoints with sqlc
  • Implement full-text search using PostgreSQL tsvector
What you will build
  • Build a read model with SQL JOINs
  • Add dynamic ordering and filtering to queries
  • Implement full-text search with PostgreSQL
What you will learn
  • Define module contracts that prevent accidental coupling between teams
  • Use the client/server pattern for inter-module communication
  • Prevent import cycles that turn a monolith into a Big Ball of Mud
What you will build
  • Define a module contract with a clear public API
  • Implement a contract server that exposes module functionality
  • Call another module through its contract without direct imports
What you will learn
  • Implement a full order lifecycle with explicit state transitions
  • Build multi-perspective read models for customers, restaurants, and couriers
  • Integrate all modules into a working end-to-end system
What you will build
  • Implement the order placement and delivery workflow
  • Build listing endpoints with different perspectives per user role
  • Verify the full system with end-to-end integration tests

You'll receive all future updates for free.
We're planning modules on observability, gRPC, and security next. Go Event-Driven buyers got the full 2.0 overhaul free, two years after buying.

Join the cohort

Real reviews from Go Backend Masterclass

From engineers who went through the training.

Review avatar

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.

Review avatar

Diogo Luis

Fullstack Developer, COCUS · Verified buyer

This course was a really good breath of fresh air. It is hard enough that you can push yourself and learn new concepts, while at the same time giving you the opportunity to properly absorb them instead of just repeating.

It's also great to immerse yourself on a bigger backend that you might not get the opportunity to otherwise, now that the market is more unforgiving to junior/mid developers.

Would definitely do again and most likely will do another pass with less help. It's not that friendly to beginner programmers, I'd recommend some experience with programming in general.

Review avatar

Jonathan Moreno

Software Developer, Alten · Verified buyer

A real hands-on guide to building production backend in Go, covering design, architecture, modularity and some of the patterns that keep systems maintainable as they scale.

Content and resources are provided in a very intuitive way that helps to keep focus on the topics and exercise at hand.

The basics, foundations and knowledge on modularity opened my eyes to new possibilities and also helped to understand the intent behind modern and even legacy implementation approaches that I've worked with.

Absolutely worth it. Thanks to Three Dots Labs for all the effort!

Review avatar

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!

Review avatar

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.

Review avatar

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!

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

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.

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.

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

I think I came to the right place and I would recommend this course to anyone!

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

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

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.

Review avatar

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.

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!

I'd say that's a 10/10 in terms of value for money.

Review avatar

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.

Review avatar

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.

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,912 ★ 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, 7,900+ Go developers have trusted us with their learning.

Is it for you?

We want to build the best training possible for a specific group of developers.

This training is a perfect match if:

You know Go basics and want to build real backends.

You prefer to learn by doing.

You want the industry-standard project structure without weeks of research.

You want a safe place to practice before trying things at work.

You're ok paying to save your time.

Join the cohort

You won't like it if:

You don't know Go at all yet. Start with Go in One Evening.

You're looking for a video course you can passively watch. Learning by doing is the core of our method.

You don't want to pay to learn.

Don't know Go yet? No problem!

See Go in One Evening, our training on Go basics.

Become a confident Go backend engineer for:

$888

The cohort starts in

0days
0hours
0min
0sec
Join the cohort

30-day money-back guarantee, even if you finish everything.

  • Start today. Warmup exercises open the moment you buy. The rest opens with the cohort.
  • Zero risk. Full refund up to 30 days after the cohort starts. No questions asked, even if you finished everything.
  • Lowest price, guaranteed. The price goes up after every sale. We never run promotions or discount codes.
  • Lifetime access with free updates. Pay once, keep it forever.
  • AI mentor included. It knows every exercise and the whole codebase. Ask it anything, anytime.
  • Certificate of completion. It proves you built a working backend, not that you watched videos.
  • Use your training budget. Your company probably has budget for this. Buy now, get reimbursed later. We issue invoices.
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 the cohort!
Gopher of trust

FAQ

You need basic Go knowledge: syntax, functions, structs, interfaces, and packages. If you can write a function that returns an error and check it, you're ready. Not confident in your Go yet? Every exercise comes with an example solution, so you won't get stuck.

You don't need any backend experience. The training starts from project setup and builds one layer at a time. Tools like oapi-codegen, sqlc, and testify are introduced as you go.

Early exercises are heavily guided with detailed hints. As you progress, you get more room to build things your way.

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

Getting stuck is part of learning, so there are three ways out. Tests tell you exactly what's failing. The AI mentor knows the codebase and every exercise, so you can ask it at 11 PM and get a real answer. And the authors answer on Discord. You'll receive access to private channels after joining the training.

There are no 1:1 calls: that's not possible as long as there are 24 hours in a day. If it still doesn't click, the 30-day guarantee applies.

A real, big one, built in small chunks. Every exercise adds one piece and teaches one new thing.

It's a food delivery backend: customers, restaurants and their menus, quotes with fees and taxes, and in the last module, orders paid by card and delivered by couriers. The tests verify every step.

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 whether one module imports another's internals, 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.

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 2 weeks, but going with its pace is optional. You have lifetime access, so you can also go through the exercises on your own schedule.

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.

That's how most courses die, so this one is built against it. Exercises take about 10 minutes, so there's no session too small to make progress. The cohort gives you people building alongside you. And progress is verifiable: green tests, not good intentions.

We can't want it for you, though. If it turns out the training isn't for you, the 30-day guarantee applies.

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,912 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.

That's the goal. You'll have tried the alternatives yourself, so you can explain why one fits, in a design review or in a system design interview.

Go Backend Masterclass is the first training in our Backend & Domain Engineer series. The Domain Engineer continues with the same project, adding domain modeling and DDD. Go Event-Driven is a separate track about asynchronous systems.

If you're building your backend foundations, start here.

Check the agenda above. If OpenAPI-first APIs, sqlc, the repository pattern, component testing, and modular monolith boundaries are things you use daily, this training will mostly confirm what you know. In that case, look at The Domain Engineer: it continues the same project into domain modeling.

If you've been building backends by copying whatever the last project did, you'll find plenty here.

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 need Go and your editor. Docker is optional. The project comes with Docker Compose to run it locally, but the tests run on our servers. The first module walks you through the setup.

The next one is unannounced. Sales open a few times a year at most, and the price goes up between them. If you're reading this during the sale, this is the cheapest and the soonest the training will ever be.

You can implement the training only in Go, but the patterns you'll learn (API-first design, repositories, clean architecture, module boundaries, component testing) are universal and can be applied in any programming language.

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 the cohort