#backend
Posts tagged with “backend”.
32 posts
ACID Transactions Explained With Examples
Atomicity, consistency, isolation and durability are the guarantees a transaction provides. Learn each one and the isolation levels.
Designing API Error Responses That Help
A good error response tells the client what went wrong and what to do. Learn the status codes, the body shape, and the validation errors.
API Pagination Patterns: Offset, Cursor and Keyset
Offset, cursor and keyset pagination each trade simplicity for correctness. Learn the trade-offs and which to choose for a large dataset.
API Versioning Strategies Compared
URL, header and media-type versioning each break a client differently. Learn the trade-offs and how to make a change without a new version.
Background Jobs: Queues, Workers and Retries
Move slow work out of the request. Learn the queue, the worker, the retry policy, idempotency and how to monitor a background job.
Caching Strategies: Cache-Aside, Write-Through and TTL
A cache trades freshness for speed. Learn the strategies, the invalidation problem, and the patterns that avoid a stampede.
Code Coverage: What It Measures and What It Misses
Coverage shows which lines the tests execute, not whether they assert anything. Learn the metrics, the traps, and how to use it well.
Connection Pooling Explained for Developers
Opening a connection is expensive, so a pool reuses them. Learn the sizing, the exhaustion, the timeout, and the serverless trap.
Cron vs Job Queues: When to Use Which
Cron runs on a schedule and a queue runs on an event. Learn the difference, the overlap, and the pattern that combines them.
Database Indexing Explained With Examples
An index trades write speed and space for read speed. Learn how a B-tree works, when an index is used, and the common mistakes.
Database Migrations: A Practical Guide
A migration changes a schema without losing data. Learn the safe patterns, the zero-downtime approach, and how to roll back.
Database Normalization Explained: 1NF to 3NF
Normalization removes redundancy and update anomalies. Learn the normal forms, the trade-offs, and when to denormalize deliberately.
GraphQL Basics: Schema, Queries and Resolvers
GraphQL lets the client ask for exactly what it needs. Learn the schema, the query, the resolver, and the N+1 problem in practice.
GraphQL vs REST: Choosing the Right API Style
GraphQL and REST solve different problems. Learn the trade-offs, the costs GraphQL adds, and the cases where each is the better fit.
Idempotency Keys: Making a Retry Safe
A retry can duplicate a payment. Learn the idempotency key, the storage, the race, and how the response is replayed.
Load Testing Basics: Finding Your Limits
A load test finds the point where a system degrades. Learn the metrics, the test types, and how to run one without breaking production.
Logging Levels: What to Log and at Which Level
A log level is a severity. Learn the levels, the structured log, the correlation id, and what must never be logged.
Message Queues Explained: Decoupling Services
A queue decouples a producer from a consumer. Learn the delivery guarantee, the dead letter, the ordering, and the backpressure.
Metrics, Logs and Traces: The Three Pillars Explained
Observability rests on three signals. Learn what each answers, the cardinality, the sampling, and how they combine.
MongoDB Basics: Documents, Collections and Queries
MongoDB stores a document, not a row. Learn the collection, the query, the index, the aggregation, and the schema design.
The N+1 Query Problem: Finding and Fixing It
One query becomes N+1. Learn how it happens, how to detect it, and the eager loading, batching and join fixes.
ORM vs Raw SQL: Choosing a Data Access Layer
An ORM trades control for convenience. Learn the trade-offs, the N+1 trap, and the hybrid approach most teams settle on.
Password Hashing: Choosing and Tuning an Algorithm
A password must be hashed with a slow algorithm. Learn Argon2id, bcrypt, the cost, the salt, and the migration path.
PostgreSQL Basics: Queries, Indexes and Transactions
Postgres is a relational database with a rich feature set. Learn the query, the index, the transaction, and the JSON support.
The Pub/Sub Pattern: Decoupling With Events
Publish-subscribe decouples a producer from many consumers. Learn the topic, the fan-out, the delivery, and the ordering.
Rate Limiting Algorithms: Token Bucket to Sliding Window
A rate limit protects a service from abuse. Learn the algorithms, the headers, the distributed case, and the client behaviour.
REST API Design Principles That Age Well
A well-designed REST API is predictable and hard to break. Learn resources, methods, status codes, versioning, and pagination.
SQL Joins Explained With Visual Examples
Inner, left, right, full and cross joins each return a different set of rows. Learn the difference and the mistakes that cause duplicates.
SQL vs NoSQL: Choosing a Database
Relational and non-relational databases make different trade-offs. Learn the categories, the guarantees, and how to choose.
Test Data Management: Fixtures, Factories and Fakes
Test data is the hidden cost of a test suite. Learn factories, fixtures, seeding, and how to keep tests independent and fast.
WebSockets vs Polling: Real-Time Communication Options
Polling, long polling, SSE and WebSockets each fit a different real-time need. Learn how each works and which to choose.
Rust vs Go in 2026: Which Should You Actually Learn?
Go is used by 16.4% and Rust by 14.8% of developers in 2026. Performance, concurrency, jobs, and learning curve compared so you can choose with confidence.