All guides

Everything you need before picking a language or framework. How computers work, what programming is, how the internet works, databases, APIs, version control, clean code principles, debugging, and how software is built in teams. The guide every engineer wishes they had at the start.

The concepts behind modern AI. Machine learning basics, neural networks, supervised vs unsupervised learning, transformers, LLMs, prompt engineering, and where AI fits in software engineering today.

Design patterns for scale: load balancing, caching layers, message queues, database sharding, CAP theorem, consistency models, and interview-ready case studies for real-world distributed systems.

Security fundamentals for software engineers. Threat modelling, cryptography basics, authentication and authorisation, network security, common attack vectors, secure coding practices, and how to build systems that are secure by design.

The OSI and TCP/IP models, IP addressing, subnetting, DNS, HTTP/HTTPS, TCP vs UDP, TLS/SSL, sockets, load balancers, proxies, CDNs, and the networking concepts every software engineer needs to debug, secure, and scale distributed systems.

Arrays, linked lists, trees, graphs, hash maps, sorting, searching, dynamic programming, and complexity analysis. Master the patterns that underpin every technical interview and production system.

Cloud fundamentals every engineer must know. Infrastructure models (IaaS, PaaS, SaaS), virtualisation, networking, storage, identity, compute, serverless, and how to think about cost, reliability, and security in cloud-native systems.

Discrete mathematics, graph theory, combinatorics, linear algebra, and the calculus behind ML optimisation. Includes probability and statistics for machine learning. Every topic is chosen because it is directly useful to a software engineer or ML practitioner.

Python from fundamentals to advanced patterns. Data types, OOP, decorators, generators, async/await, packaging, and writing production-quality Python code.

Core JavaScript from the ground up. Variables, functions, closures, the event loop, async/await, the DOM, fetch API, modules, and the patterns every JS developer must know.

Core Java from JVM fundamentals to production-ready code. OOP, generics, collections, streams, concurrency, testing, and modern Java features (records, sealed classes, pattern matching).

Type system deep-dive, generics, decorators, utility types, React + TS patterns, and configuring strict mode for large codebases.

Goroutines, channels, HTTP servers with net/http and Gin, database access, testing, and building binaries for production.

Kotlin from fundamentals to coroutines, Android development, Ktor for backend APIs, and interoperability with Java.

Ownership, borrowing, lifetimes, traits, generics, error handling, concurrency without data races, async Rust with Tokio, and building reliable high-performance systems with Rust's zero-cost abstractions.

C# from fundamentals to production. OOP, generics, LINQ, async/await, delegates, events, reflection, and building real applications with .NET for web, desktop, and cloud.

C from the ground up. Pointers, memory management, structs, the standard library, the build pipeline (preprocessor, compiler, linker), undefined behaviour, and writing reliable systems code that runs on every platform from microcontrollers to operating system kernels.

Modern C++ from fundamentals to expert. RAII, smart pointers, the STL, templates, move semantics, concurrency, and the modern features (C++17/20/23) that make C++ both fast and safe enough for browsers, game engines, databases, and trading systems.

Swift from the ground up. Optionals, protocols, generics, concurrency with async/await and actors, SwiftUI fundamentals, and building apps for iOS, macOS, and beyond.

From your first route to production-grade architecture. Covers Pydantic v2, async SQLAlchemy, JWT auth, WebSockets, Docker, and Kubernetes.

From models and views to REST APIs with Django REST Framework, authentication, admin, Celery workers, and production deployment.

REST APIs, dependency injection, Spring Data JPA, Spring Security, testing, and production deployment with Docker, Actuator, and Prometheus.

Build REST APIs and web apps with Flask. Covers blueprints, SQLAlchemy, JWT auth, testing, and containerised deployment.

Build fast REST APIs with Express. Covers routing, middleware, authentication, database integration with Prisma, and production patterns.

Build high-performance REST APIs in Go with Gin for routing and GORM for database access. Covers middleware, validation, migrations, and deployment.

Build web APIs and applications with ASP.NET Core. Controllers, minimal APIs, middleware, Entity Framework Core, authentication, SignalR, and deploying .NET applications to production on Linux and the cloud.

SEO from first principles to technical mastery. How search engines work, keyword research, on-page optimisation, Core Web Vitals, structured data, JavaScript SEO, international SEO, and measuring what actually moves rankings.

Structure and style every web page. Semantic HTML, the box model, Flexbox, Grid, responsive design, animations, accessibility, and building real UI from scratch.

Components, hooks, state management, context, React Router, performance optimisation, testing with React Testing Library, and building production-ready React applications.

Vue 3 from the ground up. Composition API, reactivity, components, Vue Router, Pinia for state management, and building production applications with Nuxt.

Angular from the ground up. Components, modules, dependency injection, RxJS, Angular Router, forms, HTTP client, signals, and building large-scale production applications.

App Router, server components, server actions, static and dynamic rendering, API routes, authentication, deployment to Vercel, and building full-stack applications with React.

Build beautiful, fast native apps for iOS, Android, web, and desktop from a single Dart codebase. Covers widgets, state management (Riverpod, BLoC), navigation, animations, Firebase, testing, and shipping to the App Store and Play Store.

Build iOS and Android apps with React knowledge you already have. Components, navigation, device APIs, Expo, state management, performance, and shipping to the App Store and Play Store.

Build native Android apps from the ground up. Jetpack Compose UI, ViewModel, navigation, Room database, Retrofit, Coroutines, Flows, background work with WorkManager, and publishing to the Play Store.

Build native iOS apps from the ground up. SwiftUI, UIKit fundamentals, data persistence, networking, push notifications, in-app purchases, TestFlight, and submitting to the App Store.

SQL from first query to advanced patterns. SELECT, JOIN, GROUP BY, subqueries, window functions, indexes, transactions, and the SQL concepts every developer must know before touching any database.

Design databases that scale and stay maintainable. Normalisation, ER diagrams, relationships, indexing strategies, partitioning, migrations, and the trade-offs between relational and NoSQL models.

SQL from the ground up. Schema design, queries, joins, indexing, transactions, stored procedures, replication, and performance tuning.

PostgreSQL from basics to advanced features. JSONB, full-text search, window functions, partitioning, indexing strategies, and production tuning.

Document modelling, aggregation pipeline, indexing, transactions, Atlas search, change streams, and scaling MongoDB in production.

Caching, pub/sub, streams, sorted sets, Lua scripting, Redis as a message broker, and production patterns for high-throughput systems.

Master DynamoDB from first principles. Tables, keys, and access patterns. GSIs, single-table design, transactions, and Streams. Production topics: hot partitions, DAX, cost optimisation, backups, and security.

DataFrames, Series, data cleaning, merging, grouping, time series, and building data pipelines. The essential Python data toolkit.

Fast analytical queries directly in Python, R, or the CLI without a server. SQL on DataFrames, Parquet, CSV, and JSON files, integrations with Pandas and Arrow, and building lightweight data pipelines.

Build reliable data pipelines from ingestion to analytics. ETL vs ELT, batch vs streaming, Apache Spark, Airflow orchestration, dbt transformations, data warehousing (Snowflake, BigQuery, Redshift), data lakes, and the modern data stack that turns raw data into business value.

Build full-stack apps with Supabase. Postgres database, authentication, row-level security, Edge Functions, Storage, Realtime subscriptions, pgvector for AI embeddings, and production deployment patterns.

Build and scale apps with Firebase. Firestore, Authentication, Realtime Database, Cloud Functions, Storage, Hosting, App Check, and production patterns for mobile and web applications.

Tensors, autograd, neural network building blocks, CNNs, training loops, transfer learning, distributed training, quantization, and deploying models to production with FastAPI and TorchServe.

Build LLM-powered applications with LangChain. Chains, agents, memory, RAG pipelines, vector stores, and production deployment patterns.

Build stateful, multi-step AI workflows with LangGraph. Graph-based agent orchestration, human-in-the-loop, persistence, and streaming.

Trace, debug, evaluate, and monitor LLM applications with LangSmith. Covers tracing, datasets, evals, prompt management, and production monitoring.

Design and build autonomous AI agents. Tool use, planning, memory, multi-agent systems, evaluation, and production deployment patterns.

The discipline of shipping production software with coding agents. The agent loop, delegation, spec-driven development, agent-assisted testing, review and plan patterns, context engineering, tool servers, legacy code, debugging, and fleet governance.

The algorithms behind modern ML. Linear and logistic regression, decision trees, random forests, SVMs, k-means clustering, gradient descent, backpropagation, neural network architectures, and how to choose, implement, and evaluate models from scratch.

Build systems that understand opinion and emotion in text. Text preprocessing, feature extraction (TF-IDF, embeddings), classical ML classifiers, fine-tuning transformer models (BERT, RoBERTa), evaluation metrics, and deploying NLP pipelines to production.

From your first API call to production-grade LLM systems. Prompt engineering, RAG pipelines, vector databases, tool calling, fine-tuning, agents, evals, and everything you need to ship reliable, cost-efficient LLM applications.

NLP from raw text to production pipelines. Tokenization, embeddings, spaCy, transformers, NER, text classification, fine-tuning BERT, and building real-world NLP systems.

Image processing to deep learning. OpenCV, PIL, CNNs, transfer learning, object detection with YOLO, segmentation, OCR, and deploying vision models to production.

RL from first principles to deep policy gradients. Gymnasium environments, Q-learning, DQN, PPO, SAC, multi-agent systems, and applying RL to real-world problems.

Productionising ML from experiment to deployment. DVC, MLflow, CI/CD for ML, model serving, drift detection, Kubernetes for ML, and building a mature ML platform.

Build MCP servers that give AI models access to your data and tools. Protocol internals, tool and resource design, transports, authentication, multi-server orchestration, and production deployment.

Build AI-powered apps with the OpenAI API. Chat completions, function calling, embeddings, vision, DALL-E image generation, Assistants API, fine-tuning, streaming, and production patterns for cost and latency optimisation.

Build AI-powered applications with Claude. Messages API, prompt engineering, tool use, vision, streaming, RAG patterns, system prompts, safety best practices, and production deployment with the Anthropic SDK.

Background tasks, scheduled jobs, task routing, retries, chaining, Redis and RabbitMQ as brokers, monitoring with Flower, and running Celery reliably in production.

Principles for designing APIs that last: REST constraints, versioning, auth patterns, rate limiting, OpenAPI 3.x specs, docs generation, code generation, and tools like Swagger UI and Redoc.

Schema design, queries, mutations, subscriptions, resolvers, DataLoader for N+1 prevention, authentication, and building and consuming GraphQL APIs in production.

Topics, partitions, producers, consumers, consumer groups, Kafka Streams, Schema Registry, exactly-once semantics, and building event-driven architectures.

Images, containers, volumes, networks, Docker Compose, multi-stage builds, and best practices for containerising applications for production.

Pods, deployments, services, ingress, ConfigMaps, secrets, Helm charts, auto-scaling, rolling updates, and running production workloads on Kubernetes.

Build and deploy at the edge with Cloudflare. Workers, Pages, R2 storage, D1 database, KV, Durable Objects, DNS, CDN caching, WAF, Turnstile, and production patterns for global low-latency applications.

Core AWS services: EC2, S3, RDS, Lambda, VPC, IAM, API Gateway, CloudWatch, and the fundamentals of architecting secure, scalable cloud infrastructure.

Core Azure services: App Service, Azure Functions, Cosmos DB, Azure AD, Storage, Virtual Networks, and the fundamentals of building on Microsoft's cloud platform.

Core GCP services: Cloud Run, Cloud Functions, BigQuery, Cloud SQL, GKE, IAM, and building scalable applications on Google's cloud infrastructure.

Build without managing servers. AWS Lambda, Google Cloud Functions, Azure Functions, Vercel Functions, cold starts, event triggers, and patterns for serverless architectures.

Providers, resources, modules, state management, workspaces, remote backends, and managing cloud infrastructure reliably with Terraform and OpenTofu.

Essential Linux commands, file system navigation, permissions, process management, bash scripting, cron jobs, SSH, and becoming fluent in the terminal.

Commits, branches, merging, rebasing, cherry-picking, conflict resolution, Git workflows (GitFlow, trunk-based), and collaborating on large codebases.

Workflows, triggers, jobs, steps, reusable actions, secrets management, matrix builds, deployment pipelines, and automating everything from tests to releases.

Pipeline design, build stages, test automation, deployment strategies, semantic versioning, changelogs, feature flags, blue-green deployments, rollback strategies, and building reliable delivery pipelines.

Pre-commit hooks, Ruff, Black, ESLint, Prettier, SonarQube, code coverage gates, commit message validation, and automating quality checks before code ever hits CI.

How to test software properly across any language. Unit tests, integration tests, end-to-end tests, test doubles, coverage, testing strategies, and building a culture of quality.

Write tests first. Covers pytest, unittest, mocking, fixtures, coverage, property-based testing, and TDD workflow in real projects.

The fast Vite-native unit test runner for JS, TS, React, Vue, Svelte, and Node. Setup, matchers, mocking, snapshots, coverage, browser mode, workspaces, type testing, and real-world testing patterns with MSW, hooks, stores, and CI.

Test your application the way real users use it. Playwright and Cypress from setup to CI integration, page object models, visual regression, and reliable E2E test suites.

What makes a great code review. How to give constructive feedback, what to look for, how to receive criticism, review culture, async vs synchronous review, and using code review to grow as an engineer.

The security every engineer must know. OWASP Top 10, XSS, SQL injection, CSRF, broken auth, insecure dependencies, input validation, and building secure applications by default.

Securing APIs end to end. JWT, OAuth 2.0, OpenID Connect, API keys, rate limiting, secrets management, CORS, and common API attack patterns and how to prevent them.

Know what your system is doing in production. Structured logging, metrics, distributed tracing, OpenTelemetry, Prometheus, Grafana, alerting, and building observable systems from day one.

How blockchains work, consensus mechanisms, smart contracts, Ethereum, Solidity basics, Web3, NFTs, DeFi patterns, and building decentralised applications.

Comprehensive prep for senior software engineering interviews. Covers requirements gathering, scoping, estimation, behavioral questions, technical decision-making, system design tradeoffs, observability, and how to think out loud like a senior engineer.

How to think out loud, approach problems under pressure, communicate your reasoning, and perform in live coding interviews. Covers common patterns, mock interview walkthroughs, and what interviewers actually look for.

The complete software engineering career roadmap. What to learn, how to think, and how to operate at every level: from writing your first line of code to leading teams, setting technical direction, and reaching Staff, Principal, or CTO.

The backend career roadmap. Building APIs and services, databases and storage, distributed systems thinking, performance and scaling, reliability, and how to operate as a senior backend engineer.

The frontend career roadmap. What to learn, how browsers work under the hood, performance, accessibility, architecture patterns, and how to operate as a senior frontend engineer.

How engineers think. First-principles reasoning, debugging complex systems, evaluating trade-offs, spotting assumptions, making decisions under uncertainty, and communicating your thinking clearly.

Write clearly as an engineer. Documentation, Architecture Decision Records, RFCs, technical proposals, README files, runbooks, and communicating complex ideas to both technical and non-technical audiences.

How to onboard as a senior engineer: mapping an unfamiliar stack before day 1, reading architecture from config files, finding and shipping the first PR, handling tech stack gaps, managing information overload, building a personal knowledge system, using AI with balance, and communicating ownership to your manager. Includes concrete patterns for serverless Java, DynamoDB access design, and LangGraph-based AI features.

Processes, threads, scheduling, memory management, virtual memory, file systems, I/O, system calls, inter-process communication, and the kernel concepts every systems-aware engineer should understand.

Lexing, parsing, ASTs, semantic analysis, type checking, intermediate representations, code generation, and optimisation passes. Understand how languages like Python, Go, and Rust turn source code into running programs.

Microcontrollers, bare-metal programming, memory-mapped I/O, interrupts, RTOS concepts, communication protocols (UART, SPI, I2C), power management, and writing firmware in C and Rust for resource-constrained devices.

How images are computed and drawn. The graphics pipeline, rasterisation vs ray tracing, shaders (vertex, fragment, compute), OpenGL, WebGL, Vulkan basics, transformations, lighting models, textures, and GPU architecture, from first triangle to real-time 3D rendering.