Skip to main content
Coming: in 2026

Dive into Backend
with Go

Learn Go for practical backend development with real-world applications. Build production-ready projects.

Created by
6,200+ Go devs trainedWatermill 9,617 ★Wild Workouts Go DDD example 6,260 ★270K+ yearly blog readers

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

Examples and tasks are extremely relevant for anyone trying to write event-driven application, all recognized as "yeah this is a problem we are solving/need to solve".

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.

Definitely recommending this for all of our developers as the problems and solutions are daily struggle in any distributed system.

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.

Petr Vitek

Petr Vitek

Developer
Previous training verified buyer

Your guide to
Go backend development

Backend development evolved rapidly, with Go emerging as a powerful language for building scalable systems. Many developers are getting into Go for its simplicity and efficiency in handling concurrent operations.

However, mastering Go for backend development involves more than just learning syntax. It's also about understanding best practices, design patterns, and real-world application architectures.

We've been developing production backend systems in Go since 2017. Our experience spans from microservices to modular monoliths, and we've documented numerous patterns and pitfalls on our blog.

After Go in One Evening, and Go Event-Driven this is another training running on our interactive learning platform. Sign up to help us measure the demand. We'll let you know once it's ready.

Laptop
Gopher of time

You can't buy time

Shortcuts work on a side project. They fall apart when three teams need to ship in the same codebase without breaking each other. We've been shipping production systems for 17 years. Long enough to know which shortcuts end in rewrites.

Go Backend Masterclass lets you skip the costly production mistakes and architectural dead-ends we already made. Years of hard-won lessons, distilled to what works.

Gopher of success

Real-world examples

Most tutorials teach you syntax with toy examples that fall apart in production. Real projects have messy requirements, edge cases, and compromises that no textbook covers.

Go Backend Masterclass is built around a production-style project where you solve problems that only show up at scale. Every exercise is something you'd face on a real team. Not a single toy demo.

Practical Gopher

Hands-On

In real life, you don't work on projects alone. We'll work together as a team. We write the boring code. You write the most enjoyable and critical code.

Not videos you passively watch. Not theory you read and forget. You run a CLI command, write code in your IDE, and tests validate your solution immediately.

It's not another course that feels like homework. It's a training that feels like work on a world-class team.

What will you learn?

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

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

See the list of topics we plan to cover below.
The exact content may change as we develop the training.

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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
You will implement
  • 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
What you will learn
  • Design gRPC services with Protocol Buffers for efficient inter-service communication
  • Run REST and gRPC side by side with gRPC-Gateway
  • Choose between HTTP and gRPC based on your use case
You will implement
  • Define protobuf schemas and generate Go server and client code
  • Expose gRPC endpoints alongside your existing HTTP API
  • Communicate between services using gRPC
What you will learn
  • Implement authentication and authorization patterns for backend APIs
  • Secure endpoints with middleware that doesn't leak into business logic
  • Handle user sessions and tokens in a production-ready way
You will implement
  • Add authentication middleware to your HTTP server
  • Implement role-based access control
  • Secure inter-service communication
What you will learn
  • Add distributed tracing across services with OpenTelemetry
  • Collect and expose metrics for production monitoring
  • Build health check endpoints that reflect real service status
You will implement
  • Instrument your services with OpenTelemetry tracing
  • Set up metrics collection and export
  • Build health check endpoints

You'll receive all future updates for free. We're planning to add modules on observability, gRPC, and more.

Stay in your environment. Use your favorite tools.

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

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

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

You can solve the exercises at any time that suits you best. You can start the training in a few months or even a year.

Inside our training

Based on the example of our Go Event-Driven training.

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

Don't miss when the training is ready

Go Backend Masterclass is not available yet. We are planning the release in 2026. Usually, our training are available to buy for just two weeks, twice a year. Join the waiting list and be the first to know.