Notes on building backends that scale.
Syed writes about distributed systems, queues, multi-tenant design, and the trade-offs behind real production code.
- 4 min read
Designing a Database Schema You Won't Regret
Schema decisions are the ones you live with longest and change most painfully. Here's how I approach data modeling — entities, keys, relationships, normalization, and knowing when to break the rules.
DatabasesPostgreSQLBackendArchitecture - 3 min read
LangGraph: When Your Agent Needs a State Machine
LCEL pipelines are straight lines. Real agents loop, branch, retry, and remember. LangGraph models an LLM app as a graph of nodes over shared state — here's the mental model and a working ReAct-style loop.
AIGenAILangGraphLLM - 3 min read
Fine-Tuning vs RAG: Which One Your Problem Actually Needs
When an LLM doesn't know your domain, two paths get proposed: fine-tune it, or give it retrieval. They solve genuinely different problems, and picking the wrong one is expensive. Here's the decision framework.
AIGenAIRAGLLM - 3 min read
PostgreSQL Indexes: When They Help and When They Lie
An index can turn a 2-second query into 2 milliseconds — or sit there costing you writes while the planner ignores it. Here's how B-tree indexes actually work in Postgres, and how to tell a useful one from decoration.
PostgreSQLDatabasesBackendPerformance - 3 min read
Multi-Tenant Architecture Without the Footguns
One database, many organizations, zero data leaks. The guard chain, tenant context, and per-tenant feature flags I use to keep tenants isolated and the codebase sane.
BackendArchitectureMulti-TenancyNestJS - 4 min read
The Transformer Architecture, From Attention Up
Self-attention, multi-head, positional encoding, and the residual-plus-norm skeleton — the transformer explained the way it finally clicked for me, one mechanism at a time.
AIGenAITransformersDeep Learning - 3 min read
Vector Databases: What They Are and When You Actually Need One
Every RAG tutorial reaches for a vector database. Most small projects don't need one. Here's what a vector DB actually does, how similarity search works under the hood, and the honest threshold for when it earns its place.
AIGenAIDatabasesRAG - 4 min read
Kafka Fundamentals: Partitions, Consumer Groups, and Ordering
Kafka isn't a message queue — it's a distributed commit log, and that one distinction explains partitions, consumer groups, ordering guarantees, and every scaling decision you'll make with it.
KafkaDistributed SystemsEvent-DrivenBackend - 4 min read
RAG That Actually Works: Lessons From a File-Based Retrieval System
Retrieval-augmented generation is simple in theory and full of sharp edges in practice. Here's what I learned building the grounded chatbot on this site — chunking, embeddings, cosine retrieval, and keeping the model honest.
AIGenAIRAGLLM - 4 min read
Transactions and Isolation Levels, Demystified
ACID gets recited in interviews and forgotten in code. But isolation levels decide whether two concurrent requests corrupt your data — here's what actually happens under the hood, with the anomalies you're trading off.
DatabasesPostgreSQLConcurrencyBackend - 3 min read
Event-Driven Architecture: Choreography vs Orchestration
Going event-driven decouples your services — and immediately forces a choice about how a multi-step workflow is coordinated. Choreography or orchestration? Here's the trade-off and how I decide.
Event-DrivenDistributed SystemsArchitectureBackend - 3 min read
Redis-Backed Queuing Pipelines That Don't Fall Over
How I use Redis and Bull to move slow, heavy work off the request path — bulk imports, campaign fires, and code judging — without blocking users or losing jobs.
BackendRedisDistributed SystemsNestJS - 4 min read
Reading a Postgres Query Plan with EXPLAIN ANALYZE
When a query is slow, guessing is a waste of time — the database will tell you exactly what it's doing if you ask. Here's how to read EXPLAIN ANALYZE, spot the red flags, and fix the query that's dragging your endpoint.
PostgreSQLDatabasesPerformanceBackend - 3 min read
LangChain in Production: LCEL, Retrievers, and the Traps
LangChain is easy to demo and easy to over-use. Here's the mental model that keeps it useful — the pipe operator, retriever chains, structured output, and the places it quietly bites you.
AIGenAILangChainLLM - 4 min read
Multi-Tenancy at the Database Layer
One app, many customers, one big question: how do you keep tenant A's data invisible to tenant B? The three isolation models — shared row, schema-per-tenant, database-per-tenant — and the trade-offs I weighed building a real multi-tenant SaaS.
DatabasesPostgreSQLArchitectureBackend - 3 min read
Java Concurrency in 2026: From Executors to Virtual Threads
Threads, thread pools, and why virtual threads (Project Loom) change how you write I/O-heavy Java. A working tour from the classic executor model to the millions-of-threads world.
JavaConcurrencyBackend - 3 min read
Monolith vs Microservices: The Decision, Not the Dogma
Microservices are sold as the grown-up architecture and monoliths as the thing you outgrow. The truth is less flattering to both. Here's how to decide by what your problem actually needs — and why most teams should start with a monolith.
ArchitectureDistributed SystemsBackend - 3 min read
Spring Boot Under Load: Pools, Timeouts, and Backpressure
A Spring Boot app that's fine in dev can fall over the first time real traffic hits. The failures are almost always the same three: exhausted connection pools, missing timeouts, and no backpressure. Here's how to get ahead of them.
JavaSpring BootBackendDistributed Systems - 4 min read
Distributed Systems: The Failures You'll Actually Hit
Forget the academic version. These are the failures that actually show up when you split one process into many — partial failure, retries and duplicates, clock skew, and why idempotency is the skill that saves you.
Distributed SystemsArchitectureBackend - 3 min read
Designing REST APIs That Age Well
An API is a contract you have to keep. Get the resources, status codes, pagination, and error shapes right early and clients trust it for years; get them wrong and every change is a breaking one. The conventions that hold up.
APIBackendArchitecture - 3 min read
Data Science, Data Analysis, and ML: Drawing the Real Lines
Three titles, endless overlap, and a lot of job-post confusion. Here's how I actually separate data analysis, data science, and machine learning — by the question each one answers.
Data ScienceMachine LearningData Analysis - 3 min read
Redis Is More Than a Cache
Most teams use Redis as a key-value cache and stop there. But its data structures make it a rate limiter, a queue, a leaderboard, and a pub/sub bus — here's the Redis I actually reach for on backends.
RedisBackendDistributed SystemsDatabases - 4 min read
Kubernetes for People Who Ship Services
Kubernetes has a reputation for complexity, most of which you can ignore at first. Here's the minimum mental model — pods, deployments, services — that lets you actually run a containerized backend and understand what's happening.
KubernetesDevOpsDistributed SystemsBackend - 3 min read
A Practical EDA Workflow (Before You Touch a Model)
Exploratory data analysis is the step everyone rushes and later regrets. Here's the repeatable pandas workflow I run on any new dataset — shape, quality, distributions, and relationships — before modeling anything.
Data ScienceData AnalysisPython - 3 min read
SQL vs NoSQL: Choose by Access Pattern, Not Hype
The SQL-versus-NoSQL debate is usually framed as a religion. It's actually an engineering decision driven by one question: how will you read and write this data? Here's the framework I use.
DatabasesSQLNoSQLArchitecture - 4 min read
Git Beyond the Basics: Rebase, Reflog, and Recovering Anything
Once commit, push, and pull are muscle memory, a handful of commands change how you actually work with Git — interactive rebase for clean history, and the reflog, which means you can almost never truly lose work.
GitToolingBackend - 3 min read
Docker for Backend Engineers: Images, Layers, and Small Containers
Docker stops being magic once you understand three things: what an image really is, how the layer cache decides your build speed, and why multi-stage builds turn a 1.2GB image into 80MB. A practical tour.
DockerDevOpsBackendTooling