MySQL Internals
The storage engine at byte level. Pages, B+trees, MVCC, locking, redo, replication — ending in a storage engine you wrote yourself.
Deep dives,
read or presented.
Browser internals to kernels, ledgers to Yoruba history. Animated figures, sources on every claim, and every part playable as slides with voice.
93courses948parts2,282chapters
SQL, The Language
The language as a formal system. Evaluation order, three-valued logic, window frames, recursion — then a SQL interpreter of your own.
Core Banking Architecture
One prompt, sixteen rounds of pressure. Ledger, concurrency, sharding, Kafka, loans, rails, cards, fraud, reconciliation, protocols, data at scale: a bank at 20M users.
Deploying The Core Bank
The same bank, on AWS and on GCP, side by side. Which managed service for which component, what it costs, where it bites, and what you would refuse to move.
Running It, And The Team
The system exists. Now keep it reliable, secure, observable, fast and changeable, with people who sleep. Non-functionals as engineering, plus on-call, tech debt and leading the work.
The Browser
How a tab works from the socket to the pixel: processes and threads, the network stack, parsing, style, layout, paint and composite, the event loop, storage, security, navigation, media, measurement, and a browser built in TypeScript at the end.
JavaScript, the Engine and the Language
What runs your code and how: the V8 pipeline, hidden classes and inline caches, optimisation and deoptimisation, memory and GC, value representation, then the language from the engine side, design patterns as mechanisms, and honest performance measurement.
Algorithms Frontend Runs On
The algorithms you write for a UI and the ones the platform runs underneath: windowing, diffing, caches, search, sort, graphs, scheduling, then selector matching, layout, paint, V8, reconciliation, compilers and text, each with its complexity and a measurement.
React, Internals and Patterns
From the fiber up: the mental model and its leaks, fiber and the two trees, reconciliation, lanes and the scheduler, hooks as a list, concurrent rendering and Suspense, Server Components and the compiler, then state, data, forms, patterns, anti-patterns, testing and hydration at scale.
Frontend System Design
Nine frontend systems designed from a brief and a set of numbers, grown in increments as the numbers change: data tables to ten million rows, compute and media pipelines, dashboards, collaborative editing, lists at scale, social feeds, real-time, and a trading screen.
DevTools, With a Companion App
Every Chrome DevTools panel explained as a window onto a pipeline stage, with a companion app where a route triggers one pathology at a time: detached nodes, layout thrash, non-passive scroll, CORS, bfcache blockers, and five full diagnoses.
Frontend Architecture and Scale
Repo structure and dependency rules, the build pipeline as a cache hierarchy, a testing strategy that admits where the pyramid lies, client observability, monorepos and microfrontends, and what breaks at a hundred thousand, a million and a hundred million users.
Money, Identity and Trust on the Frontend
The surfaces where a frontend mistake costs money or locks someone out: authentication and passkeys, KYC journeys, deposits and withdrawals with idempotency, wallets and balances, trading UIs, statements, the catalogue of degraded states, and the client half of the ledger.
How FAANG-Scale Frontend Teams Actually Work
The org shape and machinery of a two-thousand-engineer frontend: hermetic monorepo builds, internal frameworks over React, Relay-style data layers with masking, design systems upgraded by codemod, experiment platforms with holdouts, release trains, review culture, on-call, and the libraries these companies wrote and why.
Platformization: Products Across Many Countries
One product in many countries without twelve forks: the economics of a shared core, tenancy and residency, config as a product, localisation and money, regulators in adapters, extension points and a versioned core, launching and migrating and deprecating a country, and the teams across time zones.
TypeScript at Staff Level
TypeScript as a language of its own: the assignability lattice, narrowing as control flow, variance, conditional and mapped and template types, declaration files, the compiler from scanner to emitter with its performance levers, library versus app typing, and domain modelling that makes illegal states unrepresentable.
Design Systems, UI and UX
The design system as an engineering product: tokens in tiers with theming, components with accessibility built in, versioning and governance, the thinking patterns of UI and UX, working with Product and UX including when to push back, and the tooling that keeps it honest.
Accessibility and the Frontend Disciplines
Accessibility in depth (WCAG, ARIA, the accessibility tree, focus and keyboard, screen readers, contrast, motion, forms, live regions, testing) and the other disciplines as gates: performance, client observability, client security, internationalisation, and privacy.
Frontend Terms, Visualised
Several hundred frontend terms, each with a diagram, a one-line meaning, where it shows up in practice, and a link into the course that goes deep, grouped by layer from the network to architecture.
Cloud Engineering
The cloud from first principles: regions and the shared responsibility model, failure domains and availability math, networking down to the packet, compute choices, what a container is, storage and data, identity and secrets, AWS and GCP side by side, and the bill as a metric.
Infrastructure and Platforms at Scale
Running a lot of infrastructure with many teams: the service layers, infrastructure as code, Kubernetes properly, configuration and secrets, CI/CD at scale with progressive delivery, platform engineering as a product, and the team structures that scale with it.
Distributed Systems
The theory beneath every backend: partial failure, clocks and causality, consensus and Raft, replication, partitioning, consistency models, failure detection and idempotency, logs and streams, transactions across services, and the papers that proved what is possible.
Site Reliability Engineering
Reliability as a number: the contract with velocity, SLIs, SLOs, error budgets and burn-rate alerts, symptom-based paging, incident response, blameless postmortems, capacity and release safety, toil, and the frontend engineer's share.
Build Your Own
Ten systems built from scratch with tested companion repos: Redis, Kafka, a compiler, a transpiler, a signals framework, a fiber-based UI framework, a bundler, an OS kernel slice, an LSM storage engine and an HTTP server, each with animations, code walkthroughs and exercises.
How Computers Work
The machine under everything: gates and the fetch-decode-execute cycle, pipelines, branch prediction and out-of-order execution, caches and virtual memory, processes, scheduling and syscalls, file systems and SSDs, networking down to packets, and a browser tab on top of it all.
Systems Engineering
The discipline from aerospace applied to software: the V-model, requirements and traceability, interface control, FMEA, fault trees and safety cases, trade studies, and capacity and whole-life cost, worked through one regulated fintech service.
Software Patterns and the Books
The pattern vocabulary beyond the frontend, then ten books reduced to the ideas that change how you build: DDIA, Clean Architecture, A Philosophy of Software Design, The Pragmatic Programmer, SRE, Accelerate, Team Topologies, DDD, Release It! and Refactoring, applied to frontend and fintech work.
AI-Native Engineering
The development loop rebuilt around agents and products with models inside: specs as working memory, personas and skills, orchestration, test generation and review, legible codebases, guardrails and the money-flow line, grounding, cost firewalls, deterministic stubs and eval as a release gate.
The Deriv Round
Preparation for the Deriv Staff/Principal Frontend process: the JD read line by line, the architecture deep-dive drawn live, system design on cashier, KYC, trading and onboarding, money and trust questions, AI-workflow answers with evidence, the design pushback drill, and the close.
The Production Stack
What every runtime is paired with in production: reverse proxies, app servers, process managers, poolers, caches, queues, background workers, discovery, gateways and observability agents, with pairing tables per language and how stacks grow.
Configuration, Secrets and Feature Flags
Configuration and secrets from twelve-factor to production scale: config layers, HashiCorp Vault and dynamic credentials, cloud secret managers and Kubernetes integrations, Consul and etcd, rotation without downtime, feature flags, config as code and config incidents.
Deployment Techniques
Every deployment technique from rolling and blue-green to automated canaries, shadow traffic, dark launches and flags, with migrations during deploys, GitOps, non-Kubernetes platforms, serverless and edge, mobile releases and rollback strategy.
Service Mesh, Gateways and Sidecars
The sidecar pattern and service meshes from the proxy up: Envoy internals and xDS, Istio and Linkerd, ambient and eBPF meshes, Dapr building blocks, Spring Cloud, API gateways, where resilience logic belongs, and the real cost of a mesh.
Backend System Design
Backend system design in rounds: a method and ten designs (URL shortener, rate limiter, payments ledger, chat, news feed, notifications, file storage, search, job scheduler, multi-country transfers), each with questions, numbers, versions and what breaks them.
Ledgers, Payments and Reconciliation
Ledger engineering for fintech: double-entry accounting in code, journal and balance schemas with holds, end-to-end idempotency, payment state machines, rails and webhooks, reconciliation, settlement and FX, fees, interest and rounding, audit, and a capstone ledger service.
Identity, Authentication and Authorisation
Identity end to end: sessions and tokens, OAuth 2.1 and OIDC flows, JWT pitfalls, passkeys and MFA, RBAC, ABAC and ReBAC, Zanzibar-style authorisation, service-to-service identity with mTLS and SPIFFE, multi-tenant isolation, account recovery and fraud.
API Design and Contracts
API design as a product discipline: resource modelling, REST, gRPC, GraphQL and event APIs, errors, pagination and filtering, versioning and deprecation, idempotency, SDK generation and developer experience, contract testing and API governance.
Backend Debugging and Diagnostics
Diagnosing production backends: a method, syscalls with strace and lsof, CPU profiling with perf, pprof, async-profiler and py-spy, memory and GC, locks, network capture, database-side diagnosis, core dumps and eBPF, with a lab of seven deliberate pathologies.
Product Management
Product management for engineers: discovery and jobs to be done, strategy and positioning, roadmaps and prioritisation, PRDs, metrics and guardrails, experiments and launches, collaboration, stakeholders and go-to-market, and fintech business models and unit economics.
Product Thinking and Product Engineering
Product engineering: owning outcomes, finding the problem behind the ticket, slicing small valuable releases, instrumenting and measuring, using data and user contact daily, speed versus quality judgement, product taste, and case studies from Linear, Stripe and Nigerian fintechs.
Systems Thinking and Critical Thinking
A thinking toolkit for engineers: systems thinking, mental models, the structure of arguments, cognitive biases, statistical traps, evaluating sources, decisions under uncertainty, and writing as thinking.
Problem Solving, from Puzzles to Problems at Scale
A method for problem solving from puzzles to organisations: Pólya's four steps, understanding before solving, decomposition, analogy and working backwards, debugging, estimation, trade-off problems, ambiguous problems at scale, unblocking teams, and case drills.
Code Review and Merge Discipline
The craft of code review and merging: what review is for, reading a pull request in order, writing and receiving feedback, PR size, stacking and descriptions, merge strategies and branch protection, review at scale with owners and bots, and review as teaching.
Data Structures and Algorithms, Complete
The complete data structures and algorithms foundation: complexity and amortisation, arrays and lists, hashing, balanced trees, heaps, graph algorithms, dynamic programming, greedy methods, string algorithms, randomised algorithms and interview patterns, with timings measured on this machine.
Computer Networking, Complete
Networking from the wire up: layers, Ethernet, IP and BGP, TCP in depth with congestion control, UDP and QUIC, DNS, TLS 1.3, HTTP/1.1 through HTTP/3, NAT and firewalls, packet capture, and a TCP stack built over a TUN device.
Operating Systems, Complete
Operating systems in full: processes and threads with measured costs, scheduling, virtual memory and paging, synchronisation, file systems, IO and drivers, booting, security and isolation, and an xv6 walkthrough.
Concurrency and Parallelism
Concurrency and parallelism across languages: races, locks, condition variables, deadlock, lock-free techniques, memory models, async/await internals, actors and CSP, Amdahl's law, and one problem solved in Node, Go, Rust, Java and Python.
Cryptography and Security Foundations
Cryptography for engineers: hashes and MACs, AES-GCM and ChaCha20-Poly1305, RSA and elliptic curves, signatures and key exchange, PKI and certificates, TLS assembled from primitives, password hashing, misuse patterns and threat modelling, with measured costs.
Go, with Gin
Go from first program to production: types, interfaces and generics, the runtime and scheduler, goroutines, channels and context, idioms, testing and tooling, Gin and net/http internals, profiling, the production stack Go is paired with, and a ledger API capstone.
Python, with Django
Python from first program to production with Django: types and hints, CPython internals, the GIL measured, asyncio and processes, idioms, pytest and tooling, Django ORM, admin, middleware and DRF, FastAPI, profiling, the production stack and a ledger API capstone.
Java, with Spring Boot and Quarkus
Java from first program to production: modern language features, the JVM, JIT and garbage collectors, virtual threads measured, Spring Boot with DI, JPA and Security, Spring internals, Quarkus and GraalVM native images, profiling with JFR, Spring Cloud, Kafka and sidecars, and a ledger capstone.
Rust, with Axum
Rust from first program to production: ownership, borrowing and lifetimes, traits and generics, unsafe, Send and Sync, async with Tokio, idioms, cargo tooling, Axum with Tower and sqlx, profiling, the production stack, and a ledger API capstone.
Ruby and Rails
Ruby and Rails from first program to production: the object model and metaprogramming, the GVL and YJIT, concurrency with Puma and Ractors, idioms, RSpec and Minitest, Active Record, Hotwire and Active Job, Rack and Rails internals, profiling, Puma, Sidekiq, Solid Queue, PgBouncer and Kamal, and a ledger capstone.
Cassandra and MongoDB
Cassandra and MongoDB in depth: why NoSQL happened, LSM trees and compaction, Cassandra's ring, gossip and tunable consistency, query-first modelling, MongoDB's BSON, WiredTiger, indexing and aggregation, replica sets and sharding, operations, an honest comparison, and build-your-own engines.
Redis and Caching
Redis in depth with measured throughput: data structures and encodings, the single-threaded event loop and IO threads, RDB and AOF persistence, eviction, replication, Sentinel and Cluster, Lua and pipelining, streams and queues, locks and rate limiters, and operating Redis and Valkey.
Kafka and Event Streaming
Kafka in depth: the log abstraction, partitions and segments, replication, ISR and KRaft, producers with batching and idempotence, consumer groups and offsets, exactly-once transactions, Schema Registry, Connect and Debezium CDC, Kafka Streams and Flink, operations, and alternatives.
Jobs, Queues and Workflows
Background work done reliably: jobs and idempotent handlers, delivery semantics, retries, backoff and dead letters, RabbitMQ and SQS, scheduling at scale, sagas and compensation, Temporal durable execution, outbox and inbox, observability, and a workflow engine capstone.
Search Engines
Search engines from the inside: inverted indexes and postings, analysis and tokenisation, TF-IDF and BM25 scoring, Lucene segments and merges, Elasticsearch and OpenSearch clusters, relevance tuning and evaluation, vector and hybrid search, and building a small search engine.
Algorithms Backends Run On
The algorithms inside backend infrastructure: rate limiters, consistent and rendezvous hashing, Bloom filters, HyperLogLog measured in Redis, count-min sketches, B-trees, LSM trees and skip lists, timing wheels, compression, Merkle trees, backoff and load balancing, and Raft in code.
Backend Architecture and Scale
Backend architecture at scale: monolith versus modular monolith versus services, hexagonal and clean architecture, DDD aggregates and domain events, data ownership, events, choreography and orchestration, sync versus async, multi-tenancy, and three incident logs: distributed monolith, shared database, event storm.
Backend Disciplines
Cross-cutting backend disciplines: the OWASP API Security Top 10, injection, SSRF, deserialisation and secrets, performance budgets, observability conventions, NDPA and GDPR retention and deletion, cost engineering, reliability habits, and accessible APIs with server-side internationalisation.
Big-company Backend
Backend engineering in large organisations: service ownership and catalogues, RFCs and design review, API and schema governance, migrations across hundreds of services, finishing deprecations, on-call culture, paved roads, and cross-team dependencies and planning.
Data Engineering Basics
Data engineering for backend engineers: OLTP vs OLAP, columnar storage measured with DuckDB, ETL and ELT with dbt, warehouses, lakes and lakehouses, dimensional modelling, Airflow and Dagster, data quality and contracts, and CDC from Postgres into analytics.
C and Systems Programming
C and systems programming from zero: pointers, memory, the toolchain and ELF, syscalls measured, descriptors, processes and signals, sockets and poll, pthreads, allocators measured, undefined behaviour and sanitisers, and a capstone shell, allocator and HTTP server.
Linux Kernel Internals
Linux kernel internals along real code paths: syscall entry, CFS and EEVDF scheduling, page tables, faults, reclaim and the OOM killer, VFS and the page cache, the block layer, the networking stack, cgroups and namespaces, modules and drivers, and reading the source.
Systems Performance and eBPF
Systems performance on Linux: USE method and workload characterisation, the 60-second checklist, CPU, memory, file system, disk and network analysis, perf and flame graphs, eBPF and bpftrace one-liners, and disciplined tuning.
Containers and Virtualisation from Scratch
Containers from scratch: namespaces, cgroups v2, overlayfs layers, a container runtime in Go, OCI images and runtimes (runc, containerd), seccomp, capabilities and rootless, KVM hypervisors, and Firecracker and gVisor sandboxes.
Storage Systems and File Systems
Storage from the device up: SSD internals and write amplification, durable writes measured (page cache 8-10 µs, fsync 50 µs, full flush 3 ms), ext4, XFS, btrfs and ZFS, journaling and copy-on-write, RAID and erasure coding, object storage, and distributed file systems.
Discrete Maths for Programmers
Discrete maths through code: logic and proof, sets and functions, induction and recursion, counting and the birthday bound computed, graphs, modular arithmetic, primes and the Luhn check, relations and orders, and recurrences with the master theorem.
Theory of Computation
Theory of computation for working engineers: automata and regular languages with ReDoS measured in Node, grammars and parsing, Turing machines, the halting problem and Rice's theorem, P versus NP and reductions, and living with NP-hard problems.
Programming Languages and Paradigms
Programming language ideas across TypeScript, Go, Rust, Python, Java, Elixir and Haskell: values and types, type systems and variance, memory models, functional and object-oriented programming, concurrency models, evaluation strategies, and learning any language fast.
Compilers and Interpreters
Compilers and interpreters stage by stage with a real 471-line TypeScript compiler: lexing, recursive descent and Pratt parsing, ASTs, type checking, IR and SSA, optimisation passes, code generation, bytecode VMs and JITs, garbage collectors, and a capstone that extends it.
Probability and Statistics for Engineers
Probability and statistics for engineers with seeded simulations: skewed latency and percentiles, tail amplification under fan-out, sampling, bootstrap intervals, A/B test peeking (24.1% false positives), regression, Bayes and base rates, queueing and Little's law, and benchmark noise.
Linear Algebra and the Maths of ML
Linear algebra and ML maths with runnable code: vectors and matrices, cosine similarity and embeddings, linear maps, eigenvectors by power iteration and PCA, derivatives and gradients, gradient descent with learning rates that converge and diverge, and softmax and cross-entropy.
Git, Unix and the Shell
Git internals shown with real hashes, merges, rebases, bisect and reflog recovery, the Unix philosophy, strict-mode shell scripting, pipes and processes, grep, sed, awk and jq one-liners, SSH keys, config and tunnels, and make and task runners.
How LLMs Work
How large language models work: tokenisation measured with o200k_base (Yoruba vs English), embeddings, attention and transformers, training stages, LoRA, inference with the KV cache computed, batching and quantisation, evaluation, and running models locally with bandwidth arithmetic.
Flutter and Mobile Internals
Mobile internals for Flutter and React Native: the Flutter engine and Impeller, widget, element and render trees, Dart isolates measured, platform channels and FFI, React Native's new architecture, low-end Android performance, offline sync, and store releases with staged rollouts.
Technical Writing and Influence
Technical writing and influence for staff engineers: design docs and RFCs, strategy documents (diagnosis, guiding policy, actions), decision records, writing for executives, presenting, and running design reviews, with templates and before-and-after rewrites.
Interviewing at Staff Level
Interviewing at senior and staff level: the loop by stage, coding rounds, frontend and backend system design, behavioural and leadership stories, a question bank mapped to every Learna course, scored mock rounds, and negotiating level and compensation.
Yoruba History
Yoruba history with maps and timelines: Ile-Ife and creation accounts, Ife art, the Oyo Empire, Ifa and the orisa, the wider Yoruba states, the fall of Old Oyo and the 19th-century wars, Islam and Christianity, Lagos and colonial rule, the diaspora, and modern Nigeria, with sources per chapter.
West African Kingdoms
West African kingdoms with maps and timelines: Nok, Ghana and the trans-Saharan trade, Mali and Mansa Musa, Songhai, Kanem-Bornu, the Hausa states and Sokoto, Benin and 1897, Nri and Igbo-Ukwu, Dahomey and Asante, and the Atlantic slave trade, with sources per chapter.
China
Chinese history with maps and timelines: Neolithic cultures and the Xia question, Shang oracle bones and the Zhou Mandate of Heaven, the Hundred Schools, Qin and Han, Sui-Tang, Song, Yuan, Ming and Zheng He, Qing and the Opium Wars, the Republic and People's Republic, and reform and China today.
Ancient Kingdoms of the World
Ancient kingdoms worldwide with maps and timelines: Mesopotamia, Egypt, Kush and Meroë, Aksum, Persia, Greece, Rome, Maurya and Gupta India, the Maya, Aztecs and Inca, Great Zimbabwe and the Swahili coast, the Mongols, and why empires rise and fall.
Modern Nigeria and Africa, 1800 to Today
Modern Nigerian and African history: the 19th-century jihad and missions, the Scramble and the Berlin Conference, colonial Nigeria and 1914, nationalism and independence, the First Republic and civil war, military rule and oil, the Fourth Republic, and Africa's economies and technology today.
A History of Computing
A history of computing from the abacus and Babbage to Turing, wartime machines, mainframes, Unix and C, the personal computer, ARPANET and the web, and mobile, cloud and AI, including women written out of the story and computing's arrival in Africa.
Elixir and Phoenix
Elixir and Phoenix from intro to expert with measurements on the BEAM (one million processes, 1.15 µs messages, supervisor restarts): pattern matching, OTP and supervision, Phoenix, Ecto and LiveView, performance, production pairings (libcluster, Oban), and the ledger capstone.
Kotlin
Kotlin from intro to expert with measured coroutines: null safety and sealed types, the JVM and Java interop, coroutines, Flow and structured concurrency, idioms, testing, Ktor and Spring Boot, performance, production pairings shared with Java, and the ledger capstone.
C# and .NET
C# and .NET from intro to expert with measurements on .NET 10: records and pattern matching, value types (struct vs class measured), nullable references, the CLR, JIT and GC, async/await (100,000 tasks measured), ASP.NET Core and EF Core, performance, production pairings, and the ledger capstone.
Node.js Internals
The Node.js runtime from V8 and libuv up: the event loop phase by phase, streams and backpressure, modules, native addons, workers, HTTP internals, database drivers and pooling, profiling, production deployment, observability and security.
PostgreSQL Internals
PostgreSQL from the inside: process architecture, 8 KB pages and tuple headers, MVCC, vacuum and wraparound, every index access method, WAL and recovery, the planner, extensions, replication and CDC, partitioning and operations, with an extension and FDW capstone.
Scaling Databases
The decisions that scale a database, in order: measuring limits, query and schema work, pooling, caching, replicas, sharding with Vitess and Citus, multi-region NewSQL, CDC and streaming, reliability, and a written decision framework.
ORM Internals
How ORMs work and fail: the object-relational mismatch, identity maps, units of work, lazy loading and N+1, query building and hydration, Prisma, Drizzle, TypeORM, Kysely, MikroORM, Hibernate, ActiveRecord, SQLAlchemy and Django, staff-level practice, and building an ORM.
Formal Database Theory
Formal database theory with a working TypeScript capstone: the relational model and NULL, relational algebra, calculus and Codd's theorem, FDs, closures, keys and normal forms to 6NF, query containment and join ordering, serialisability, 2PL, SI and SSI, CAP, PACELC, FLP, quorums and CRDTs, storage structures, and Adya and Jepsen.