Skip to content
Velloreth

#backend

Posts tagged with “backend”.

32 posts

01

ACID Transactions Explained With Examples

Atomicity, consistency, isolation and durability are the guarantees a transaction provides. Learn each one and the isolation levels.

02

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.

03

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.

04

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.

05

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.

06

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.

07

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.

08

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.

09

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.

10

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.

11

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.

12

Database Normalization Explained: 1NF to 3NF

Normalization removes redundancy and update anomalies. Learn the normal forms, the trade-offs, and when to denormalize deliberately.

13

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.

14

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.

15

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.

16

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.

17

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.

18

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.

19

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.

20

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.

21

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.

22

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.

23

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.

24

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.

25

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.

26

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.

27

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.

28

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.

29

SQL vs NoSQL: Choosing a Database

Relational and non-relational databases make different trade-offs. Learn the categories, the guarantees, and how to choose.

30

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.

31

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.

32

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.