Learn how real systems work
Deep, interactive courses from first principles to production, with animated diagrams, notebooks and a quiz after every lesson.
19
courses
269+
hours of lessons
7,561
quiz questions
All courses
Build production AI systems — retrieval-augmented generation, autonomous agents, evaluation, interpretability, safety, and inference optimization. Bridge the gap between research papers and shipped products.
Work AWS as an engineer, not a diagram. IAM policy evaluation, instance families and pricing models, Lambda cold starts, DynamoDB capacity and key design, VPC routing, EventBridge and Kinesis, IaC, quotas and throttling, and the bill.
Process data that does not fit on one machine. The economics of scaling out, object storage as the storage layer, Parquet and ORC, the move from MapReduce to DAG engines, stage and task scheduling, shuffle internals, partitioning and skew, Spark architecture and its memory model, Catalyst and Tungsten, join strategies, tuning a real job, Iceberg and Delta and Hudi, ACID on object storage, compaction and file sizing, Trino and federated query, warehouse engines, OLAP stores, Flink and state backends, event time and watermarks, exactly once, orchestration, incremental models, data quality gates, catalogs, and cost control.
Master the building blocks of cloud-native systems — compute, storage, networking, serverless, containers, IaC, CI/CD, and multi-region architecture.
What a container actually is at the kernel level, how images are built and layered, and then Kubernetes from the inside. Control plane components, the reconcile loop, pod lifecycle, the scheduler's two phases, requests and limits, services and name resolution, storage, custom resources and operators, authorisation, upgrades and disruption budgets, and the method for debugging a cluster that has stopped working.
Understand the internals of data systems — storage engines, replication, partitioning, transactions, batch processing, and stream processing. Based on the concepts from Martin Kleppmann's "Designing Data-Intensive Applications."
Open the database. Page layout and the slotted page, the buffer pool and its replacement policy, B-trees with latching and splits, LSM trees and compaction, write-ahead logging and crash recovery, torn pages and the double write buffer, isolation levels with the anomalies behind them, the lock manager, MVCC visibility and serializable snapshot isolation, the parser and the cost model, join algorithms and join ordering, the execution engine, access paths, partitioning, replication, two-phase commit, consensus-backed storage, distributed execution, and then tours of Postgres, InnoDB, SQLite and RocksDB.
Master algorithmic patterns and data structures through hands-on LeetCode-style problems - from arrays and hashing to dynamic programming and advanced graphs.
Understand how AI agents work, from LLM foundations to production-ready agent architectures.
Kafka below the API surface. Record formats, segment files and indexes, the page cache and zero-copy path, the controller and ISR, producer and consumer internals, transactions and the last stable offset, Connect and Streams, and the arithmetic an operator actually does.
Learn how machine learning systems are built, deployed, and operated at scale — from feature engineering to model serving to monitoring.
The network as a backend engineer actually meets it. Frames and packets, the TCP state machine and congestion control, QUIC, DNS and TLS end to end, HTTP/2 and gRPC on the wire, load balancing and NAT, anycast and CDNs, the delay product, connection ceilings, and the captures and filters you need when it breaks.
Operate what you ship. Metrics, logs, traces and profiles as four different measurements, instrumentation with OpenTelemetry, the arithmetic of cardinality, sampling that keeps the interesting traces, Prometheus internals and PromQL, long term storage, log pipelines, distributed tracing in practice, correlating signals during an incident, service level objectives and error budgets, alerting on symptoms, dashboards people actually open, on-call and incident command, postmortems that change something, CI pipelines, blue green and canary deployments, GitOps, feature flags, capacity planning, load testing, chaos experiments and cost as a reliability concern.
Master object-oriented design from first principles, SOLID, design patterns, and classic interview problems with hands-on coding.
RabbitMQ below the API surface. The AMQP model and its frames, classic queue internals and quorum queues on Raft, streams, persistence and the memory alarms, confirms and acknowledgements, dead-letter topologies, credit-based flow control, clustering and partitions, the pattern catalogue, and the operations an upgrade actually requires.
Redis below the command surface. The event loop and where it stopped being single threaded, RESP and pipelining, the object encodings and the thresholds that convert them, jemalloc arenas and fragmentation, expiration and approximated LRU, RDB forks and AOF rewrites, replication and the backlog, Sentinel and Cluster failover with their real consistency limits, scripts and transactions, locks, and the handful of numbers an incident actually needs.
Security as an engineering discipline. Threat modeling, the cryptography you will actually use, identity and authorization models, the vulnerability classes that keep shipping, secrets and cloud least privilege, supply chain integrity, detection, and incident response.
Build a strong foundation in designing scalable, reliable distributed systems.
A short course that equips you with the skills to approach system design interviews methodically.
Nothing here covers what you need?
Basis Lab writes one for you from a sentence about what you want to be able to do, then teaches it and checks you understood. Your first course is free.