Blog

A Reader's Guide to ThreeDotsLabs.tech

Cover Image for A Reader's Guide to ThreeDotsLabs.tech
ZD
ZD
All tags

ThreeDotsLabs.tech is one of my favorite indie developer blogs. I stumbled onto it while digging into DDD and Go — a genuine treasure trove. Beyond excellent long-form posts, the authors compiled their work into an e-book. In early 2025 they quit their jobs to go all-in, treating the blog, open source, and training courses as a real business. This post finishes the outline I started back then — a map for anyone else feeling lost in the same territory.

Who They Are

Two dots, three authors? No — it's the Polish duo Miłosz Smółka and Robert Laszczak. They met in high school and have been writing software together for over fifteen years. They fell into Go in 2016. Their backgrounds span finance, healthcare, and security; they've led teams and founded startups. These aren't academic lecturers — they're the kind of people who've shipped messy code and survived production incidents.

Their About page is refreshingly blunt: they refuse to flatten the real world into feel-good tutorials, they don't sell silver bullets, they're bootstrapped, and they don't take vendor sponsorships. That stance runs through everything they publish.

Go Skills: Not Syntax 101, but Go That Pays the Bills

The Go community used to be skeptical of DDD and layered architecture. "Don't write Java in Go" — I've heard that line more times than I can count. One of Three Dots Labs' core contributions is explaining how to write business-oriented Go — not for range tutorials, but:

  • Long-form blog posts: often 10k+ words with full context. Take Live website updates with Go, SSE, and htmx — you can find ten "Hello SSE" posts elsewhere; they insist on production-grade detail.
  • Training courses: after quitting, they shifted focus to Go In One Evening (Go for people who already know how to code) and Go Event-Driven (event-driven systems in practice). The format is CLI + local IDE, not browser-based TODO apps — feedback loops stay tight.
  • Anti-pattern collection: go-web-app-antipatterns — short examples of code that runs but shouldn't be copied.

If you already know another language and want to move into Go backend work: Go In One Evening → pick blog posts that interest you → Go Event-Driven is a time-efficient path.

Architecture: DDD Lite, Not DDD Religion

The most valuable material for me is the Modern Business Software in Go series — about fourteen articles built around Wild Workouts, a gym booking app, refactored incrementally.

They deliberately seeded the initial codebase with common tech debt: anemic models, services bloated into "eight-thousand-line monsters," domains driven by the database schema — then they dismantle it piece by piece:

Topic Key article What you'll learn
Intro Introduction to DDD Lite When microservices aren't enough; how domain models escape the DB
Layers Clean Architecture in Go Ports and adapters — stop stuffing everything into main
Combo Combining DDD, CQRS, and Clean Architecture How to stack three patterns pragmatically
Mindset DDD: A Toolbox, Not a Religion When to use it — and when not to over-engineer

The e-book Go With The Domain is the series in bound form: Serverless (Cloud Run), gRPC, DDD, Clean Architecture — subscribe to their newsletter and the PDF is free. When your team can't stop arguing about "should we use DDD in Go," handing them this book often beats another meeting.

Hands-On: Wild Workouts and Watermill

Reading alone isn't enough — they ship runnable code on GitHub:

Suggested approach: clone Wild Workouts first, then read the series while reviewing git diffs — an order of magnitude more effective than scrolling Markdown alone.

Brand Building: Quitting, Newsletter, Build in Public

Being good at tech doesn't guarantee survival. What's interesting about Three Dots Labs is how openly they discuss sustainable software education:

  • Jan 2025 We quit our jobs: Robert left a principal role; Miłosz went all-in too. They disclosed training revenue (~746 trainees, ~$129k in 2024), mortgages, and newborn kids — not success porn.
  • Newsletter 18k+: their long-term channel for posts, courses, and podcast updates; they don't bet heavily on social algorithms.
  • No Silver Bullet podcast: live and recorded conversations; the space between "Engineers" and "Shippers" matters. Miłosz's The Over-Engineering Pendulum is essential prep reading.
  • Build in Public: financials and mistakes shared every twelve weeks — indie dev / small-team monetization as a public experiment.

The playbook resembles "course + community + open-source funnel" elsewhere, but the difference is depth tied tightly to code assets — not a three-day anxiety-selling bootcamp.

Recommended Reading Order (Cheat Sheet)

  1. Completely new: About page + DDD Lite intro + clone Wild Workouts.
  2. Go backend experience, want architecture: work through the series index; when stuck, cross-reference Go With The Domain.
  3. Messaging / event systems: Watermill docs + Go Event-Driven syllabus.
  4. Curious how technical content pays the bills: quit-your-jobs post + No Silver Bullet podcast — read as a case study.

Closing Thoughts

Three Dots Labs isn't the only team teaching Go architecture, but they're unusually consistent on depth, reproducible code, and long-term thinking. The article count isn't huge — quality over quantity — so spread it across several sittings, each paired with a Wild Workouts refactor diff.

I started this post in April 2025 and shelved it; by October I'd nearly written it off as abandoned. Consider the gap filled. They're still publishing on their end — if you're in the same line of work, bookmark it and revisit occasionally. Beats scrolling short posts.

References