Stop Ignoring Schema Evolution In Kafka
Why you need to treat your event schemas as first-class citizens.
Back to Blog
Archive
Software Architecture
A curated collection of thoughts, tutorials, and insights related to Software Architecture.
Data Lakes Versus Data Warehouses Explained
Stop guessing between data lakes and warehouses. Here is the practical guide.
Fixing Redis Caching Bugs For Real
Stop guessing your cache invalidation strategies and start debugging them effectively.
tRPC vs GraphQL: Which Should Choose
I break down when to pick tRPC over GraphQL for your next web project.
Stop Optimizing Before You Have Data
Learn why premature optimization is a trap that hurts your codebase and velocity.
Why Queues Smooth Your Traffic Spikes
Stop your server from crashing when traffic hits with simple task queues.
Choosing Boring Technology Deliberately
Why choosing proven tech stacks beats chasing shiny new frameworks every time.
Should You Use GraphQL Schema Stitching?
Why I'm skeptical of GraphQL schema stitching for modern microservice architectures.
API Gateway vs Reverse Proxy
Understanding when to use an API gateway versus a simple reverse proxy.
Migrate CodeIgniter to Laravel Without Pain
Stop the big-bang rewrite. Here is how to migrate from CodeIgniter to Laravel.
React Fiber Explained for Frontend Engineers
Understand how React Fiber manages UI rendering and scheduling.
How Kubernetes Decides Where Pods Run
Understanding how the Kubernetes scheduler handles your pod placement decisions.
OAuth 2.0 Flows: Visualizing The Difference
I break down OAuth 2.0 flows visually to help you choose the right one.
Bytecode vs Native Code: The Reality
A practical look at the trade-offs between bytecode and native compilation.
Designing a Zero Trust Architecture
Learn to secure your infrastructure by moving away from perimeter-based security.
Why Retries Are Killing Your API
Learn how naive retry logic causes cascading failures and how to fix it.
When Abstraction Leaks are Okay
Discover when abstraction leaks are acceptable in software development.
SOLID Principles Meet Functional Programming
Exploring how SOLID principles can be applied in functional programming for better code.
Multi-Tenant SaaS: Designing for Scale
Learn how to build robust, scalable multi-tenant SaaS architectures.
Strangler Fig Pattern Explained for Developers
Learn the Strangler Fig pattern for modernizing legacy systems.
Monolith vs Microservices: When to Break Up
Deciding between monolith and microservices architecture. Learn when to split your app.
Explicit Tradeoffs in Design
Making design tradeoffs clear benefits teams and product quality.
Scaling Session Management Made Easy
Managing user sessions at scale can be tricky. Let's break it down.
Understanding Dead Letter Queues
Learn what Dead Letter Queues are and why they're essential for robust applications.
Explore other topics
Need to Message Me?
Let's Talk!