Advanced Async Patterns in Python
Beyond `await` — task groups, cancellation, timeouts, and structured concurrency.
Algorithms
Core algorithms every software engineer must know — sorting, searching, recursion, dynamic programming, and the patterns that connect them.
API Design
Designing HTTP APIs that are intuitive, consistent, and maintainable. Good API design is about the consumer's experience — the API is a product, not just an implementation detail.
API Security
Securing APIs against authentication attacks, injection, abuse, and data exposure.
API Versioning and Backward Compatibility
Evolving APIs without breaking existing clients. The hardest constraint in API design: you can add anything, but removing or changing existing behaviour will break someone.
Architecture Patterns
Structural approaches to organising application code. The right architecture makes code easier to test, change, and understand. The wrong one creates coupling that makes every change expensive.
Auth Patterns
Authentication (who are you?) and authorisation (what can you do?). Getting auth wrong is the most common source of security vulnerabilities. Use established protocols rather than inventing your own.
Background Jobs and Task Queues
Offloading work from the request/response cycle — email sending, report generation, data processing.
Caching Strategies
Storing computed or fetched data closer to where it's needed to reduce latency and backend load. Caching is the most common performance optimisation — and a common source of bugs when done wrong.
CI/CD Pipelines
CI/CD pipeline design as a discipline — stage ordering (lint→build→test→scan→staging→prod), artifact promotion, Jenkins Declarative Pipeline, Azure DevOps YAML stages, and the four DORA metrics that measure delivery performance.
Clean Code
Writing code that is easy to read, understand, and change. Clean code is not about aesthetics — it's about reducing the cognitive cost of every future change.
CLI Tooling
Building professional command-line tools with Click, Typer, and Rich.
Code Review
A structured review of code changes before they merge. Done well, code review catches bugs, spreads knowledge, enforces standards, and is the most effective quality gate a team has.
Concurrency
Running multiple tasks that overlap in time. Concurrency is about structure (managing many tasks); parallelism is about execution (running on multiple CPUs simultaneously).
CQRS and Event Sourcing
Separating reads from writes, and storing state as a sequence of events rather than current values.
Data Structures
The core data structures every software engineer must know — what each is, when to use it, and the time/space complexity that governs that choice.
Data Validation with Pydantic v2
Schema definition, custom validators, serialisation, and defensive data handling at system boundaries.
Database Design
Designing relational database schemas for correctness, performance, and maintainability. Good schema design prevents bugs, makes queries fast, and reduces the cost of future changes.
Database Transactions
ACID guarantees, isolation levels, deadlocks, and patterns for correct concurrent data access.
Debugging Systems
Debugging as a first-class engineering skill — systematic elimination, correlation IDs, tracing across services, and reproducing production failures.
Dependency Injection
Providing dependencies from outside rather than creating them inside — the key to testable, composable code.
Distributed Systems
Systems where computation spans multiple machines connected by a network.
Domain-Driven Design
Aligning software design with the business domain. DDD provides a vocabulary and set of patterns for modelling complex business domains — making the code reflect the real world rather than database ta...
Error Handling Patterns
Designing error handling that is informative, testable, and does not silently swallow failures.
Event-Driven Architecture
Systems that communicate by producing and consuming events rather than direct calls. Temporal decoupling: producer doesn't wait for consumer; spatial decoupling: producer doesn't know who consumes.
Feature Flags
Decoupling deployment from release — ship code dark, control visibility independently.
Git
Git fundamentals for software engineers — staging, committing, branching, merging, rebasing, and the PR workflow used in professional teams.
GraphQL
A query language for APIs and a runtime for executing those queries. Clients request exactly the data they need; the schema is the contract.
gRPC
A high-performance RPC framework using Protocol Buffers for serialisation. Strongly typed, auto-generated clients, 4 streaming modes. Preferred for internal service-to-service communication at scale.
Linux Fundamentals
Core Linux knowledge for software engineers: process management, file system, networking, shell scripting, and systemd. Essential for anyone running services in production.
Logging Best Practices
Structured, queryable logs that help you debug production issues without drowning in noise.
Message Queues
Asynchronous communication between services. Queues decouple producers from consumers: the producer doesn't wait for the consumer; the consumer processes at its own pace.
Microservices Patterns
Architectural patterns for systems composed of independently deployable services.
Networking
Networking fundamentals for software engineers — HTTP/HTTPS, DNS, TCP/IP, status codes, headers, WebSockets, and how the web actually works.
NoSQL Databases
NoSQL covers four distinct families (document, key-value, wide-column, graph) each with different consistency models and query trade-offs. PostgreSQL + Redis is the most common 2026 production stack; NoSQL wins when data shape is variable, write throughput is extreme, or relationship traversal dominates.
Observability for Software Engineers
Instrumenting applications so you can understand their runtime behaviour without modifying code. The three pillars: logs, metrics, traces. Modern production systems are undebuggable without them.
OOP and Design Patterns
Object-oriented programming and design patterns — classes, inheritance, composition, SOLID principles, and the four patterns that appear most in real codebases.
OS Internals
OS behaviour that explains production failures — processes vs threads, virtual memory, CPU scheduling, file systems, and what OOM kills and context switches actually cost.
Performance Optimisation
Systematic approach to improving system performance: measure first, optimise the bottleneck, measure again.
Python Basics
The entry point for the vault's 0→SE→AE path. Covers the language features you need before moving on to [[cs-fundamentals/oop-patterns]] and [[python/ecosystem]].
Python Packaging and Distribution
Modern Python package management with uv, pyproject.toml, and publishing to PyPI.
Python Type Annotations
Advanced typing patterns that make code self-documenting, statically verifiable, and composable.
Security Fundamentals for Software Engineers
Application security principles every engineer must know — not a specialisation, a baseline.
Software Design Principles
Heuristics for making code decisions. Not laws — principles that, when violated, should have a reason. Knowing when NOT to apply them is as important as applying them.
SQL
Stub page — SQL content has moved to [[sql/sql-fundamentals]].
Streaming Patterns
Server-Sent Events, chunked responses, and backpressure — the mechanics of real-time data delivery.
System Design
How to design systems that scale — the vocabulary, tradeoffs, and building blocks used in every production architecture interview and real backend design conversation.
Test-Driven Development
Write a failing test before writing code. The test defines the contract; the implementation satisfies it.
WebSockets
Persistent bidirectional connections for real-time features — chat, live feeds, collaborative editing.