Docs
85 docs across 7 categories, reference-grade, no login required.
Categories
Databases
Indexing, normalization, transactions, and the storage-engine internals that decide whether a query takes a millisecond or a minute.
Frontend
Rendering models, layout systems, and the browser mechanics behind fast, accessible user interfaces.
Backend
API design, caching, and the server-side patterns that keep services fast and correct under load.
DevOps
Containers, networking, and the infrastructure primitives behind reliable deployments.
System Design
The distributed-systems building blocks used to reason about scale, availability, and trade-offs.
Algorithms
Complexity analysis and the core techniques for reasoning about how code performs at scale.
Security
Common vulnerability classes and the defensive patterns that keep applications and data safe.
All docs
AWS CloudWatch & CloudTrail
How CloudWatch metrics, logs, and alarms fit together with CloudTrail's audit trail, and why CloudTrail answers "who did what" while CloudWatch answers "what is the system doing."
AWS Compute
How EC2, Lambda, ECS, and EKS trade control for convenience differently, and how to actually choose between them instead of defaulting to whichever one you already know.
AWS IAM
How IAM users, roles, and policies control access in AWS, why roles with temporary credentials are preferred over long-lived access keys, and how policy evaluation actually decides allow versus deny.
AWS Organizations & Account Structure
How AWS Organizations, organizational units, and the AWS account itself form the real isolation boundary, and why that structure - not any single resource - is where governance and billing actually happen.
AWS Storage
How S3, EBS, and EFS fit different access patterns, what S3 storage classes actually trade off, and why durability and availability are two different numbers.
AWS VPC Networking
How Amazon VPC, subnets, security groups, and network ACLs control traffic in AWS, and why security groups (stateful, instance-level) and network ACLs (stateless, subnet-level) are not interchangeable.
Azure Active Directory (Entra ID)
How Entra ID identity, app registrations, and role-based access control fit together, and why it governs both human sign-in and workload-to-workload authentication.
Azure Compute
How Virtual Machines, App Service, and AKS trade control for convenience differently, and how to actually pick between them instead of defaulting to whichever one you already know.
Azure Fundamentals
How Azure organizes resources through management groups, subscriptions, and resource groups, and why that hierarchy, not the resources themselves, is where most governance actually happens.
Azure Monitor
How Azure Monitor, Log Analytics, and Application Insights fit together as one platform, and why KQL, not a dashboard, is where real incident investigation happens.
Azure Networking
How Virtual Networks, subnets, and Network Security Groups control traffic in Azure, and how VNet peering differs from a VPN gateway for connecting networks together.
Azure Storage
How Blob, File, and Disk storage in Azure fit different access patterns, what redundancy options (LRS, ZRS, GRS) actually protect against, and why access tiers change cost, not durability.
Bash Fundamentals
The scripting layer built on top of the shell - variables, conditionals, loops, and functions - and the quoting and exit-status habits that separate a script that looks right from one that fails safely.
Big O Notation
How to read and reason about Big O time and space complexity, with the common growth rates ranked and worked examples for each.
Binary Search
Why bisect_left and bisect_right return different insertion points for the exact same value, and why binary search silently returns a wrong answer, not an error, the moment the input isn't actually sorted.
Browser Rendering Pipeline
Why animating transform and opacity can skip layout and paint entirely while animating width or top can't, and how alternating writes and reads to layout properties in a loop forces the browser to recalculate layout over and over.
CI/CD Pipelines
What continuous integration and continuous delivery actually automate, how a pipeline stage graph is structured, and why fast feedback loops matter more than pipeline complexity.
Cloud Cost Optimization
Why idle and over-provisioned resources, not raw usage, are where most cloud spend actually leaks, and the concrete levers (rightsizing, commitment discounts, autoscaling) that address it.
Cloud IAM Fundamentals
How identity, roles, and policies fit together across cloud providers, why least-privilege is a discipline rather than a one-time setup, and the difference between authentication and authorization.
Cloud Networking Fundamentals
How virtual private clouds, subnets, and security groups model network isolation in the cloud, and why "public" vs "private" subnet is a routing decision, not a labeling one.
Cloud Service Models
What actually distinguishes IaaS, PaaS, and SaaS, why the boundary is "who manages what," and how the shared responsibility model determines what you're on the hook for at each layer.
Consistent Hashing
Why placing hosts and keys on a hash ring means adding or removing one host out of N only remaps roughly 1/N of the keys, instead of the near-total remapping a plain modulo hash would force on every single change.
Container Image Scanning
How image scanning finds known vulnerabilities before a container ever runs, and why a minimal base image and a non-root user matter more for security than any scanner added afterward.
CSS Box Model & Stacking Context
Why box-sizing changes what "width" actually measures, and why a z-index of 9999 can still render below an element with z-index 5 once stacking contexts are involved.
CSS Grid vs Flexbox
When to reach for CSS Grid versus Flexbox, the one-dimensional vs two-dimensional distinction, with syntax and layout examples for each.
Database Connection Pooling
Why transaction pooling gives far better connection reuse than session pooling, and why that same efficiency silently breaks SQL PREPARE, SET, LISTEN, and session-level advisory locks, even though PgBouncer can support protocol-level named prepared statements under transaction pooling when max_prepared_statements is enabled.
Database Locking & Deadlocks
How PostgreSQL's row-level lock modes actually differ in strength, why it can't predict which transaction a deadlock will abort, and why acquiring locks in a consistent order is the real fix, not a "nice to have".
Database Normalization
What 1NF, 2NF, and 3NF actually require, why normalization removes update anomalies, and when denormalizing on purpose is the right call.
Database Partitioning
How range, list, and hash partitioning each split one logical table into physical pieces, and why partition pruning depends entirely on the WHERE clause matching partition bounds directly, not on any index.
Database Replication
Why asynchronous replication can silently lose the most recent commits if the primary crashes, what synchronous_commit's three levels actually each guarantee, and how to measure replication lag instead of assuming it's small.
Database Sharding
Why a monotonically increasing shard key like a sequential ID or timestamp routes every new write to the same shard, and why hashed sharding fixes that distribution problem at the cost of range queries no longer targeting a single shard.
Database Transactions & Isolation Levels
Why PostgreSQL's default Read Committed isolation still allows non-repeatable reads and phantom reads, and why Repeatable Read and Serializable trade that risk for transactions your application has to be ready to retry.
Docker Fundamentals
How images, containers, volumes, and networks fit together in Docker's runtime model, and the mental shift from "installing software" to "running a packaged image" that trips up newcomers.
Docker Networking
How Docker's bridge, host, and overlay network drivers work, how container DNS resolution happens, and the port-publishing model that trips up most beginners.
Dynamic Programming
Why caching subproblem solutions turns an exponential naive recursive Fibonacci into a linear one, and what "overlapping subproblems" actually has to be true about a problem before memoization can help at all.
Embeddings & Vector Search
How embeddings turn text into vectors that cosine similarity can compare mathematically, why shortening an embedding's dimensions trades some accuracy for real storage and speed savings, and when semantic search actually beats keyword search.
Git Fundamentals
How the working directory, staging area, and commit history actually relate to each other, and why understanding that three-stage model makes branching, rebasing, and undoing changes stop feeling arbitrary.
GitOps Principles
Why treating Git as the single source of truth for cluster state, instead of running kubectl/terraform apply by hand, changes how deployments, rollbacks, and audits actually work.
Graph Traversal: BFS & DFS
Why breadth-first search's queue explores every neighbor before any of their children, guaranteeing the shortest path in an unweighted graph, while depth-first search's stack (or recursion) does the opposite and can't make that guarantee at all.
Hash Tables & the Hash/Equality Contract
Why two objects that compare equal but hash differently don't raise an error when used as a dict key, they just silently fail to find each other, and why that makes the __eq__/__hash__ contract one of the most dangerous ones to get wrong.
Idempotency in Distributed Systems
Why Stripe returns the exact same response, error included, for a reused idempotency key instead of retrying the operation, and why reusing that same key with different parameters is treated as an error, not a new request.
Infrastructure as Code Security
How policy-as-code catches a non-compliant infrastructure change at the plan stage, before anything is provisioned, and why that timing is what makes it a real control rather than a post-incident audit trail.
Kubernetes Fundamentals
How Pods, Deployments, and Services fit together, what the control loop actually does, and why Kubernetes networking confuses people coming straight from Docker Compose.
Kubernetes Security
How RBAC's default-deny, additive model, Pod Security Standards, and NetworkPolicy's default-allow-until-selected behavior fit together, and why each one surprises people coming from a simpler permissions model.
Linux Filesystem Hierarchy & Permissions
Why /etc, /var, /usr, and /opt exist as separate, standardized directories under the Filesystem Hierarchy Standard, and how chmod's octal mode and umask actually decide a new file's permissions.
Linux Fundamentals
The core command-line building blocks - navigation, permissions, processes, networking, and services - that every other Linux topic on this site (filesystem hierarchy, storage, users, networking) assumes you already have.
Linux Logging & Monitoring with journald
Why journald's default "auto" storage mode can quietly discard logs across a reboot on a fresh system, and how journalctl's unit and priority filters actually narrow down a live incident.
Linux Networking
How ip and ss replaced ifconfig and netstat as the modern tools for interfaces and sockets, what TCP socket states like LISTEN and TIME-WAIT actually mean, and how nftables organizes firewall rules into tables and chains.
Linux Process Management & systemd
Why SIGKILL can't be caught or ignored the way SIGTERM can, how systemd's Type= actually decides when a service counts as "started," and the difference between the ps command's BSD and UNIX option styles.
Linux Storage & LVM
How physical volumes, volume groups, and logical volumes let LVM pool multiple disks and resize storage without repartitioning, and what mount and /etc/fstab actually do to attach a filesystem to the directory tree.
Linux Users, Groups & sudo
How /etc/passwd and /etc/shadow split identity from password storage, why a UID (not a username) is what the kernel actually checks, and how a sudoers rule's who/where/as-whom/what structure grants privileges.
LLM Evaluation & Reducing Hallucinations
Why "it feels better" isn't a shippable justification for a prompt change, what an LLM-graded eval actually measures, and why explicitly allowing "I don't know" is one of the most effective, cheapest hallucination fixes available.
LLM Fundamentals: Tokens, Context Windows & Sampling
Why a token isn't a word, what actually happens when a request would exceed the context window, and what temperature and top_p each control during generation.
Load Balancers
How load balancers distribute traffic across servers, algorithms, health checks, Layer 4 vs Layer 7, and the failure modes that show up at scale.
Message Queues & Event-Driven Architecture
Why a visibility timeout, not a delete, is what actually protects a message from being processed twice, and why "at-least-once delivery" means your consumer has to handle duplicates even when everything is configured correctly.
Observability Fundamentals
How logs, metrics, and traces answer different questions, why "we have monitoring" isn't the same as being able to debug an incident, and the cardinality trap that breaks metrics systems.
Platform Engineering Fundamentals
What an internal developer platform actually is, why "golden paths" beat unlimited flexibility, and how platform engineering differs from just having a good DevOps team.
PostgreSQL Fundamentals
How tables, joins, aggregates, window functions, and transactions fit together in everyday PostgreSQL work, from the actual internals of a single index (covered in PostgreSQL Indexes) to the SQL you write day to day.
PostgreSQL Indexes
How B-Tree, Hash, GIN, BRIN, and covering indexes work in PostgreSQL, when to create them, how to inspect usage, and the write-overhead trade-offs at scale.
Prompt Engineering
Why a role set in the system prompt shapes every response differently than the same instruction in a user message, and why 3-5 well-chosen examples reliably steer output format better than more instructions alone.
Python Async Programming
How asyncio's single-threaded event loop achieves concurrency without threads, why blocking calls silently defeat it, and when async actually helps versus when it's pure overhead.
Python Data Structures
When to reach for a list, tuple, dict, or set based on what operations you actually need fast, and why choosing the wrong one is a common hidden performance bug.
Python Syntax Fundamentals
How Python's significant whitespace, dynamic typing, and object model shape idiomatic code, and the mutable-default-argument trap that catches almost everyone once.
Python Virtual Environments & Packaging
Why every Python project needs an isolated environment, what a lockfile actually pins down that a requirements list doesn't, and how to avoid the global-install dependency trap.
Python Web Frameworks Overview
How Flask, Django, and FastAPI trade minimalism, batteries-included structure, and async-first design differently, and how to actually choose based on project shape.
Rate Limiting Algorithms
How the token bucket algorithm AWS API Gateway actually uses separates a steady-state rate from a burst allowance, and why a request only fails once the bucket is genuinely empty, not the instant the average rate is exceeded.
React Hooks Deep Dive
How useState, useEffect, useMemo, and useCallback actually work under the hood, plus the dependency-array and stale-closure pitfalls that trip up most React code.
React Rendering & Reconciliation
Why React associates a component's state with its position in the tree, not the component instance, and why using an array index as a list key silently attaches the wrong state to the wrong item once the list reorders.
Recursion & the Call Stack
Why CPython's recursion limit exists to protect the real, platform-dependent C stack rather than being an arbitrary language rule, and why raising it too high can still crash the interpreter instead of just allowing deeper recursion. Verified against CPython 3.12; exact stack behavior, default limit, and crash mode are interpreter- and version-specific, not universal across every Python implementation.
Redis Caching Patterns
Cache-aside, write-through, and write-behind explained, plus the TTL, stampede, and invalidation pitfalls that show up once Redis caching hits real traffic.
REST vs GraphQL
The real trade-offs between REST and GraphQL, over/under-fetching, caching, versioning, and when each one is the better default for an API.
Retrieval-Augmented Generation (RAG)
Why a document chunk embedded in isolation loses the context that made it meaningful, and how prepending explanatory context to each chunk before embedding measurably cut retrieval failures in Anthropic's own published results.
Secrets Management
Why centralized, short-lived secrets replace hardcoded credentials in a mature DevSecOps pipeline, and which common patterns, environment variables included, quietly leak secrets anyway.
Secure CI/CD Pipelines
How SAST, dependency (SCA) scanning, and DAST fit into a build pipeline as automated gates, and why failing the build on a real finding is what actually makes "shift-left" more than a slogan.
Service Mesh Basics
What a sidecar proxy actually intercepts, why service meshes exist once you already have Kubernetes Services, and the mTLS/observability/traffic-shaping capabilities that justify the added complexity.
Sorting Algorithms & Stability
Why a "stable" sort guarantees equal-key elements keep their original relative order, and how Python's Timsort exploits already-sorted runs in real data to hit O(n) on the best case instead of always paying O(n log n).
SQL Injection Prevention
How SQL injection actually works, why parameterized queries are the real fix (not string escaping), and the defense-in-depth practices that back them up.
SQL Joins & Query Planning
Why the same JOIN can execute as a nested loop, a hash join, or a merge join depending entirely on table size and available sort order, and why "it's impossible to suppress nested loops entirely" is a real, documented planner constraint.
Terraform Basics
How Terraform's declarative state model, providers, and plan/apply workflow let infrastructure be versioned and reviewed like code, and the state pitfalls that trip up most teams.
Testing Python with pytest
How pytest's fixture system and plain-assert philosophy replace unittest's boilerplate, and why fixture scope is the setting most likely to cause confusing test failures.
The CAP Theorem
Why partition tolerance isn't actually optional for a distributed system, and why that leaves only a choice between consistency and availability once a real network partition happens, not a free choice among all three properties all the time.
The JavaScript Event Loop
Why every queued microtask runs before the next macrotask, ever, and how that one ordering rule explains why a Promise callback always logs before a setTimeout(fn, 0), no matter how it looks in the source.
Tool Use & Agents
How a tool call actually completes as a round trip, a tool_use block your code executes and a tool_result you send back, and why every tool definition you provide adds real tokens to every request whether or not it's ever called.
Web Accessibility Fundamentals
Why the W3C's own first rule of ARIA is to avoid ARIA whenever a native HTML element already does the job, and what WCAG's 4.5:1 versus 3:1 contrast ratios actually apply to.
Web Performance & Core Web Vitals
What LCP, INP, and CLS each actually measure, why "good" is defined at the 75th percentile of real page loads rather than the average, and why a fast average can still hide a genuinely bad user experience.