Tech
Engineering, written for builders.
System design, distributed systems, low-level design, JVM and backend craft. We write the post we wish we'd found at 11pm on a Tuesday.
Latest from the tech blog
TechApr 19, 2026 · 5 min read
SQL vs NoSQL: A Decision Framework, Not a Religion
When relational makes sense, when document or wide-column wins, and how to pick a database without falling into the 'we use Mongo because it's web-scale' trap.
TechApr 19, 2026 · 6 min read
Spring Boot Best Practices for Production
Spring Boot accelerates Java backend development but ships with defaults that need tuning for production. Configuration, observability, performance, and security practices that matter.
TechApr 19, 2026 · 6 min read
Sharding and Partitioning: Strategies, Trade-offs, and the Pain Nobody Warns You About
When to shard, how to shard, and the operational realities — hot keys, resharding, cross-shard joins — that decide whether your database scales gracefully or painfully.
TechApr 19, 2026 · 6 min read
REST vs GraphQL vs gRPC: A Working Engineer's Guide to Picking an API Style
A practical, no-hype comparison of REST, GraphQL, and gRPC — what each one optimizes for, where it bites, and how to pick the right tool for the API you're actually building.
TechApr 19, 2026 · 7 min read
OAuth 2.0 and JWT: Authentication Patterns Every Backend Engineer Should Know
OAuth 2.0 flows, JWT structure, when to use each, and the security pitfalls that compromise most implementations.
TechApr 19, 2026 · 6 min read
Microservices vs Monolith: How to Actually Decide
When a monolith is the right answer, when microservices earn their keep, and why most teams pick wrong because they're optimizing for the wrong constraint.
TechApr 19, 2026 · 6 min read
Observability for Microservices: Logs, Metrics, and Traces That Actually Help
How to instrument a service so that when something breaks at 3am, you can find the cause in minutes — not hours. Logs, metrics, traces, and the patterns that tie them together.
TechApr 19, 2026 · 6 min read
Message Queues Compared: Kafka, RabbitMQ, SQS, and When to Use Each
Choosing a message queue locks in architectural decisions for years. The major options compared by throughput, ordering, durability, and operational complexity.
TechApr 19, 2026 · 6 min read
Load Balancing Strategies: L4 vs L7, Round Robin, and What 'Sticky Sessions' Really Cost
How load balancers actually distribute traffic — L4 vs L7, the algorithms that matter (round robin, least connections, consistent hashing), and the hidden costs of sticky sessions.
TechApr 19, 2026 · 7 min read
Load Balancers Deep Dive: L4 vs L7, Algorithms, and Real Trade-offs
Load balancers are everywhere but rarely understood deeply. Layer 4 vs Layer 7, algorithm choices, health checks, and the configurations that matter in production.
TechApr 19, 2026 · 6 min read
Kubernetes Fundamentals: What It Is, What It Solves, and When You Don't Need It
Kubernetes is the dominant container orchestrator but adds significant operational complexity. The core abstractions, when it's worth the cost, and the simpler alternatives.
TechApr 19, 2026 · 6 min read
Kafka Explained Simply: Topics, Partitions, Consumers, and the Mental Model That Makes It Click
Kafka isn't a queue — it's a distributed log. Once you internalize that one shift, the partitions, consumer groups, offsets, and replay semantics all start to make sense.
TechApr 19, 2026 · 6 min read
JWT Explained: When to Use Them, When to Run, and What People Get Wrong
JSON Web Tokens are useful, popular, and routinely misused. A practical guide to what JWTs actually solve, where they fail, and the patterns that keep auth simple and safe.
TechApr 19, 2026 · 6 min read
JVM Garbage Collection: G1, ZGC, and How to Pick One Without Reading 800 Pages of Spec
What the JVM garbage collectors actually do, the trade-offs between G1, ZGC, Shenandoah, and Parallel, and how to pick one for the workload you're actually running.
TechApr 19, 2026 · 6 min read
Idempotency in APIs: Why It Matters and How to Actually Implement It
Networks retry. Idempotency is what keeps a single user click from creating two charges. A practical guide to designing idempotent APIs without painting yourself into a corner.
TechApr 19, 2026 · 6 min read
How CDNs Actually Work: Edge, Origin, and the Magic in Between
What a CDN really does, the cache headers that drive it, how to invalidate, and the patterns (stale-while-revalidate, surrogate keys, edge functions) that turn a CDN from 'static asset server' into a real performance tool.
TechApr 19, 2026 · 6 min read
Eventual Consistency: What It Really Means in Production
What eventual consistency actually buys you, what it costs your users, and the patterns (read-your-writes, monotonic reads, quorum reads) that make it bearable.
TechApr 19, 2026 · 6 min read
Event-Driven Architecture: When Events Pay Off (and When They Don't)
What event-driven really means, the patterns that work — events vs commands, choreography vs orchestration, sagas, outbox — and the failure modes nobody warns you about.
TechApr 19, 2026 · 7 min read
Docker and Containers Explained: How They Actually Work
Containers transformed software deployment, but most engineers don't understand how they work under the hood. Namespaces, cgroups, layered filesystems, and what 'container' really means.
TechApr 19, 2026 · 7 min read
Distributed Locks: Redlock, Zookeeper, and Why They're Harder Than They Look
When you need a distributed lock, what your real options are (Redis, Zookeeper, Etcd), and the failure modes that make 'just use Redlock' a worse answer than it sounds.
TechApr 19, 2026 · 7 min read
Designing a URL Shortener: An Interview-Style Walkthrough
A complete walkthrough of designing a URL shortener at interview depth — requirements, ID generation, storage, caching, scaling, and the trade-offs at every step.
TechApr 19, 2026 · 6 min read
Designing Rate Limiters: Token Bucket, Leaky Bucket, and Sliding Windows
How rate limiters actually work — token bucket, leaky bucket, fixed and sliding windows — with the trade-offs that decide which one belongs in front of your API.
TechApr 19, 2026 · 7 min read
Database Sharding Explained: When, Why, and How to Do It Right
Sharding is the most common — and most misunderstood — way to scale databases. The strategies, the trade-offs, and the cases where you absolutely should not shard.
TechApr 19, 2026 · 6 min read
Database Isolation Levels: From Read Committed to Serializable, Without the Confusion
What isolation levels actually do, the anomalies each one prevents, and which level your real-world workload should use — explained without the textbook fog.
TechApr 19, 2026 · 5 min read
Database Indexing Explained: B-trees, Hash Indexes, and When to Add One
How database indexes actually work — B-trees vs hash, covering and partial indexes, the cost they impose on writes, and a practical rulebook for when to add one.
TechApr 19, 2026 · 6 min read
Circuit Breaker Pattern: How to Prevent Cascading Failures
When downstream services fail, naive retries amplify the problem. Circuit breakers detect failures and protect upstream systems. Implementation details and gotchas.
TechApr 19, 2026 · 6 min read
CDN Explained: How Edge Networks Make the Internet Fast
CDNs serve content from locations closer to users, reducing latency dramatically. How they work, what they cache, and how modern edge platforms run code at the edge.
TechApr 19, 2026 · 6 min read
CAP Theorem in Practice: PACELC and What Real Systems Actually Pick
What CAP and PACELC really say, why 'CP vs AP' is a useful but lossy summary, and how to map the theory to the database choices you'll actually make.
TechApr 19, 2026 · 6 min read
CAP Theorem and PACELC: What Distributed Systems Force You to Choose
CAP is the most-cited and most-misunderstood distributed systems concept. The real meaning, why PACELC is more accurate, and what each trade-off actually feels like in production.
TechApr 19, 2026 · 6 min read
Caching Strategies for Backend Engineers: Cache-Aside, Write-Through, and the Rest
How to actually use a cache — when to use cache-aside, write-through, write-behind, refresh-ahead — and the failure modes (thundering herd, stampede, drift) that bite in production.
TechApr 19, 2026 · 6 min read
Caching Strategies: Cache-Aside, Write-Through, Write-Back, and When to Use Each
Caching is the highest-leverage performance optimization. The patterns, the consistency trade-offs, and the invalidation strategies that actually work in production.
TechApr 19, 2026 · 6 min read
A Backend Security Checklist for Working Engineers
The non-negotiable security practices every backend engineer should ship by default — auth, input validation, secrets, transport, dependencies, and the small habits that keep systems out of breach reports.
TechApr 19, 2026 · 6 min read
API Versioning Strategies: URL, Header, and the Trade-offs Nobody Tells You
URL versioning, header versioning, content negotiation, and 'no versioning at all' — what each costs, what each gets you, and how to pick a strategy you won't regret in three years.
TechApr 19, 2026 · 6 min read
API Rate Limiting Strategies: Token Bucket, Leaky Bucket, and Sliding Window
Rate limiting protects APIs from abuse and overload. The major algorithms, when each is appropriate, and how to implement them in distributed systems.
TechApr 18, 2026 · 8 min read
System Design Basics: The Building Blocks Every Backend Engineer Should Know
A practical, no-fluff tour of the building blocks behind every large system — load balancers, caches, databases, queues, CDNs — and the trade-offs that decide how to wire them together.
TechApr 17, 2026 · 7 min read
Java Multithreading: A Working Engineer's Guide to Threads, Executors and the JMM
What thread, runnable, executor, future, completable future, virtual thread, volatile, synchronized, and the Java Memory Model actually mean — with the trade-offs that decide which one to reach for in production.
Common questions
Is the tech section just DSA?
No. The DSA, LLD, and HLD libraries are part of it, but tech also has long-form writeups on JVM internals, distributed systems, backend design, and the day-to-day craft of shipping software.
Who writes this?
Working engineers — not a content farm. Posts are opinionated and grounded in what actually works in production.
Are the system design writeups interview-grade?
Yes. The HLD section is built around the same problems you'll see at L5+ interviews; the SSE Interview Prep track inside DSA walks you through 60 days of structured practice.
Built for interview prep too
Pair the long-form writing with structured practice — the SSE Interview Prep track inside DSA is a 60-day plan we use ourselves.