Go Concurrency Patterns I Use in Every Service
Worker pools, fan-out/fan-in, pipelines, and the cancellation discipline that keeps Go services predictable under load.
Backend
Definition
Backend coverage in this archive spans 15 posts from Nov 2016 to Aug 2022 and leans into practical engineering craft: interfaces, testing, and maintainable implementation details. The strongest adjacent threads are go, architecture, and performance. Recurring title motifs include go, patterns, api, and backend.
Key claims
- The through-line is clarity first: simple designs that survive change beat clever abstractions.
- Early posts lean on go and backend, while newer posts lean on api and postgresql as constraints shifted.
- This topic repeatedly intersects with go, architecture, and performance, so design choices here rarely stand alone.
Practical checklist
- Keep interfaces small, automate regressions early, and make operational assumptions explicit in code.
- Start with the newest post to calibrate current constraints, then backtrack to older entries for first principles.
- When boundary questions appear, cross-read go and architecture before committing implementation details.
Failure modes
- Abstracting before usage patterns are stable enough to justify indirection.
- Treating style consistency as optional until quality and velocity both degrade.
- Applying guidance from 2016 to 2022 without revisiting assumptions as context changed.
Suggested reading path
- Start here (current state): Go Concurrency Patterns I Use in Every Service
- Then read (operating middle): Your API Is a Contract You Can’t Take Back
- Finish with (foundational context): Why We Chose Go for Our Backend Services
Related posts
- Go Concurrency Patterns I Use in Every Service
- Caching: The Easy Part Is Adding It, the Hard Part Is Everything Else
- Rate Limiting: The Boring Feature That Saves You at 3 AM
- PostgreSQL Performance: Measure First, Tune Second
- API Versioning: Pick One and Stop Overthinking It
- Message Queues: The Patterns Nobody Tells You About Until 3 AM
- The PostgreSQL Tuning Playbook I Actually Use
- Your API Is a Contract You Can’t Take Back
References
Caching: The Easy Part Is Adding It, the Hard Part Is Everything Else
Cache-aside, write-through, invalidation strategies, and the failure modes that will wake you up at night. With Go examples.
Rate Limiting: The Boring Feature That Saves You at 3 AM
Rate limiting algorithms, implementation tradeoffs, and practical lessons from building limiters for high-traffic APIs at a real-time messaging company.
PostgreSQL Performance: Measure First, Tune Second
Most Postgres performance problems are indexing problems. The rest are vacuum problems. Here's how to find and fix both.
API Versioning: Pick One and Stop Overthinking It
API versioning is a maintenance commitment, not a design exercise. URL paths win for public APIs, headers for internal ones. The real discipline is not versioning -- it's avoiding breaking changes in the first place.
Message Queues: The Patterns Nobody Tells You About Until 3 AM
Queues look simple on a whiteboard. Then you deploy them. Here are the messaging patterns I've learned the hard way across three startups, with Go code and real failure stories.
The PostgreSQL Tuning Playbook I Actually Use
Battle-tested PostgreSQL tuning from running fintech and startup workloads: connection pooling, memory sizing, index discipline, vacuum management, and the queries that tell you what's broken.
Your API Is a Contract You Can't Take Back
Hard-won lessons on designing HTTP APIs that survive real integrations, drawn from building fintech and mobility platforms.
Async Job Processing: Patterns That Saved Us at a Fintech Startup
Hard-won patterns for reliable background job processing -- queues, retries, idempotency, and the failures that taught me to care about all three.
API Rate Limiting: What Actually Works
Algorithms, headers, and deployment patterns for rate limiting APIs -- drawn from building financial data services at the fintech startup.
Making Go Services Fast: What Actually Matters
Practical patterns for squeezing performance out of Go services — profiling, allocation control, bounded concurrency, and HTTP/DB tuning from real production work.
GraphQL in Production Is Harder Than They Tell You
After a year running GraphQL at the fintech startup, here's what the conference talks leave out.
A Go Developer Looks at Rust for Backend Work
I write Go every day at the fintech startup. Here's why I've been spending evenings with Rust, what impressed me, and where it still hurts.
Machine Learning for Backend Engineers: What Actually Matters
What backend engineers actually need to know about ML in production -- from someone who builds NLP pipelines for financial news.
Why We Chose Go for Our Backend Services
How Go became the default backend language at Dropbyke and a fintech startup, what it replaced, and the honest tradeoffs we accepted along the way.