// Topic
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
15 posts
- 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.
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.