A creative roadmap for backend devs.
Below are some of my thoughts:
Write Once, Test Everywhere: Sharing Common Tests in Python’s unittest
How to reduce duplication in Python unittest suites by sharing common test logic across multiple test classes.
Generating Go Code from OpenAPI Specification
A practical walkthrough for generating type-safe Go code directly from OpenAPI specifications using oapi-codegen.
Behavior-Driven Development in Go
An exploration of Behavior-Driven Development in Go using GoDog, focusing on mindset, executable specifications, and writing tests that describe system behavior.
What It Takes to Be a Real Go Engineer
Knowing Go syntax is table stakes. Real Go engineering is about judgment, restraint, and knowing when the language itself is the wrong tool.
The Thundering Herd Problem
Cache stampede is when your own users become the attack. The fix is not more cache — it is treating the cache miss path like a critical section.
That Username Is Taken. How Does Google Know Instantly?
You type a username. Before you finish, it’s already taken. No network call. No lag. How?
SQL Doesn’t Run in the Order You Write It
The order you write a SQL query and the order the database executes it are completely different — and that gap explains most SQL mistakes.
My Thoughts on Domain-Driven Design in Golang
DDD is not about folder naming. Here is my lightweight take — what actually works, what gets abused, and when to just start small.
Multitenancy Lessons from Slack
Come to think of it , Slack is not a chat app. It’s a multi-tenant distributed system wearing a friendly UI. The lessons from how it handles isolation, fanout, and noisy neighbors apply far beyond messaging.
Hexagonal Architecture in Go
Most Go services start clean and turn into a tangle. Hexagonal architecture is the structural idea that keeps them untangled — here is how it works and how to apply it in Go.
Foreign Function Interfaces (FFI)
A creative exploration of Foreign Function Interfaces (FFI) — how they enable interoperability, reuse, and integration across programming languages.
Flow Control in Distributed Systems: Understanding Backpressure
An in-depth exploration of backpressure in distributed systems — why it arises, how it impacts stability and throughput, and the strategies engineers use to handle it effectively.
Escape Analysis in Go
A deep dive into escape analysis in Go — how the compiler decides whether variables live on the stack or heap, and why it matters for performance.
Caching Is Easy. Invalidation Is Where Systems Falter.
Everyone knows how to add a cache. Almost no one has a written-down invalidation strategy before shipping.