Concepts
A plain-language reference library for AI-native software engineering — factual explainers on the concepts behind the code your AI tools write, from RAG and embeddings to caching, load balancing, and CI/CD.
API Design
How to design APIs that are predictable, consistent, and easy to build on — naming, versioning, errors, pagination, and more.
Authentication and Authorization
Authentication verifies who you are. Authorization decides what you're allowed to do. This guide explains both, how sessions and tokens work, and why you should use an auth provider instead of building your own.
Caching Deep Dive
The harder parts of caching at scale — eviction policies, distributed caching, the three classic failure modes that crash databases, and why cache consistency is genuinely difficult.
Caching Fundamentals
Caching stores the result of an expensive operation so you can return it instantly next time. This guide explains browser caching, CDN caching, Redis, cache invalidation, and when to cache.
Choosing a Tech Stack
How to pick tools for your app — the modern founder stack, decisions in detail, and what to avoid early.
CI/CD Basics
CI/CD automates the process of testing and shipping code. This guide explains continuous integration, continuous deployment, how pipelines work, and how to set one up.
CI/CD Security and Supply Chain
How to protect your deployment pipeline and the software it produces — keeping secrets safe, scanning dependencies, and understanding where attacks actually happen.
Containerisation Basics
A container packages your app and everything it needs to run into a single portable unit. This guide explains Docker, images, Dockerfiles, Docker Compose, and when to use containers.
Data Modeling and Schema Design
How to design a database schema that makes features easy to add — entities, relationships, keys, normalization, and common patterns.
Database Fundamentals
A database stores and organises your app's data. This guide explains SQL vs NoSQL, when to use each, core concepts like indexes and transactions, and how to get started.
Database Migrations
A database migration is a version-controlled script that changes your database structure — adding a table, renaming a column, or updating a relationship — safely and repeatably across every environment.
Database Scaling and Performance
How to make a slow database fast — indexes, query fixes, connection pooling, caching — and when you actually need to scale to multiple machines.
Deployment Strategies
A deployment strategy controls how a new version of your app reaches users — all at once, gradually, or behind a feature flag. This guide explains the main approaches and when to use each.
DevOps
What DevOps actually means, and a map of everything involved in getting code from your editor into production safely and repeatedly.
Evaluating LLM Outputs
How to build evaluation systems for LLM-powered features — covering human eval, automated checks, LLM-as-judge, eval datasets, and regression prevention.
GitOps and Kubernetes
What Kubernetes does, what GitOps adds on top of it, and when this combination is worth adopting — explained for builders who haven't managed clusters before.
Google Cloud Services
A practical reference to Google Cloud Platform's key services — with particular focus on BigQuery, Kubernetes, Cloud Run, Firebase, and Vertex AI where GCP genuinely leads.
Infrastructure as Code
What it means to define your servers, databases, and cloud resources in text files rather than clicking through a dashboard — and why that matters for reproducibility and teamwork.
Load Balancing
What a load balancer does, how traffic gets distributed, and what you need to know as a builder using managed platforms.
Managed Platforms
The platforms that abstract away cloud complexity — hosting, databases, auth, and AI infrastructure — and how to choose between them for your stage and stack.
Message Queues and Async Processing
Message queues let your app offload slow work to the background so users get fast responses. This guide explains queues, pub/sub, workers, and key patterns like idempotency and dead letter queues.
Monitoring and Observability Basics
Monitoring tells you when your app is broken before your users do. This guide covers logs, metrics, error tracking, uptime monitoring, and the essential tools for small teams running live products.
Networking Essentials
What actually happens when a request travels across the internet — DNS, TCP, TLS, HTTP versions, and CDNs explained for builders.
Observability Deep Dive
The three pillars of observability in depth — logs, metrics, traces — plus OpenTelemetry, correlation IDs, and SLO-based alerting.
Prompting Best Practices
Prompt engineering is the practice of designing inputs to an LLM to reliably get the outputs you want — it's often the fastest way to improve AI behavior before reaching for fine-tuning.
Rate Limiting and Throttling
Rate limiting caps how many requests a client can make in a given window. It protects against abuse, runaway costs from paid APIs, and accidental self-inflicted overload.
Resilience and Fault Tolerance
Resilience is designing your app so that when parts fail — and they will — failures stay contained instead of cascading into a full outage. This guide explains timeouts, retries, circuit breakers, and graceful degradation.
Scalability Patterns
Scalability is a system's ability to handle growing load without a rewrite. This guide explains vertical vs horizontal scaling, statelessness, caching, queues, and when to reach for each pattern.
Secrets and Config Management
Every app has settings that change between environments and sensitive values that must never leak. This guide explains the difference between config and secrets, where each should live, and how to manage rotation.
Security Best Practices for Vibe Coders
The most common security mistakes when building with AI tools — and how to avoid them. Covers API keys, environment variables, database security, authentication, and frontend vs. backend.
Serverless Compute
What serverless means, when to use it, and the trade-offs that trip up builders — cold starts, statelessness, costs at scale.
SRE and Incident Management
Site Reliability Engineering — how to set reliability targets, manage incidents calmly, and run blameless postmortems so reliability compounds over time.
Structured Outputs
Structured outputs are techniques for getting LLMs to reliably produce machine-parseable data like JSON — essential for any pipeline that needs to process model responses programmatically.
System Design Basics
System design is how the individual parts of your app — database, cache, queue, and APIs — fit together into something that's fast, reliable, and able to grow. This guide covers the core building blocks and the decisions that shape every system.
Tech Stack Landscape
A map of cloud services across AWS, Azure, and GCP — compute, storage, databases, AI, DevOps, and messaging compared side by side.
Testing and QA
Automated testing lets you ship fast without breaking things. This guide explains the test pyramid, types of tests, how they fit into CI/CD, and how to get started without overcomplicating it.
The MCP Ecosystem
Model Context Protocol (MCP) is an open standard that lets AI models connect to external tools and data sources — a universal connector for building AI integrations without custom per-model code.
Understanding APIs
An API lets two pieces of software talk to each other. This guide explains REST APIs, webhooks, authentication, and status codes in plain English — with real examples.
Web Application Security
The most critical web application attack classes — SQL injection, XSS, broken access control, CSRF, and more — explained plainly with concrete defenses for each.
WebSockets and Real-Time Communication
WebSockets and Server-Sent Events let your app push data to users without them having to ask for it. This guide explains polling, SSE, and WebSockets — with examples and guidance on when to use each.
RAG — Retrieval-Augmented Generation
RAG gives an LLM access to specific knowledge at query time by retrieving relevant documents and passing them as context — without retraining the model.