Courses

Foundations · beginner · 9 min

Build the mental model behind happens-before, volatile fields, monitors, and safely publishing objects between threads.

Core concepts · intermediate · 7 min

Understand how modern ConcurrentHashMap combines volatile reads, CAS, and narrow bin-level locking, and where its guarantees stop.

Applied patterns · intermediate · 9 min

A transaction is only as good as the boundary you choose. Learn how service-layer design, isolation levels, and idempotent writes affect correctness in Java systems.

Production practice · advanced · 11 min

Separate heap pressure from thread-stack failure, collect the right evidence, and fix the retention path rather than masking symptoms.

Deep dives · advanced · 10 min

Use repeated thread dumps and thread-state patterns to distinguish deadlocks from slow dependencies, starvation, and excessive synchronization.

Deep dives · intermediate · 9 min

Diagnose collection bugs caused by inconsistent equality, mutable keys, inheritance, and accidental identity comparisons.

Deep dives · intermediate · 10 min

A practical method for investigating wrapped exceptions, null failures, resource exhaustion, and misleading catch blocks in JVM services.

Deep dives · advanced · 18 min

A production field guide to GC choice, thread-pool saturation, Spring lifecycle traps, AOP boundaries, and blocking work in reactive services.

Deep dives · intermediate · 5 min

Turn a local appointment into an instant without silently shifting nonexistent times or choosing an ambiguous offset.

Deep dives · intermediate · 6 min

Separate elapsed time from civil time and carry a shrinking deadline through a request.

Deep dives · advanced · 8 min

Trace plugin and application class loaders from long-lived roots before blaming metaspace.

Practice checkpoint

Foundations · beginner · 8 min

Understand names, object identity, mutability, typing, and validation so Python code behaves predictably as systems grow.

Core concepts · beginner · 8 min

Choose Python collection types by invariants and access patterns, then use map, comprehensions, and reductions without obscuring intent.

Applied patterns · beginner · 9 min

Turn Python exceptions into a reproducible diagnosis using traceback frames, minimal experiments, structured logging, and boundary validation.

Production practice · intermediate · 8 min

FastAPI is fast, but speed is not the same as correctness. Learn where async, background jobs, and bounded concurrency matter in Python services.

Deep dives · intermediate · 8 min

A practical guide to request concurrency, connection pools, timeouts, and overload behavior in async Python APIs.

Deep dives · intermediate · 9 min

Understand task cancellation, timeout scopes, cleanup, and the failure modes that leave background work running.

Deep dives · intermediate · 9 min

Find the hidden shared state, clock assumptions, race, or nondeterministic dependency behind tests that fail only sometimes.

Deep dives · advanced · 17 min

Understand event-loop scheduling, CPU versus I/O concurrency, ASGI worker lifecycles, per-request sessions, and cancellation-safe background work.

Deep dives · advanced · 14 min

Debug memory outside Python objects, choose ASGI worker boundaries, and find silent hangs in background consumers.

Deep dives · intermediate · 5 min

Build a small timestamp boundary that rejects naive input, normalizes aware values, and measures latency with the right clock.

Deep dives · intermediate · 6 min

Use a bounded asyncio queue to distinguish accepted work, active work, and completed work.

Deep dives · advanced · 8 min

Understand structured task lifetimes, cancellation, and grouped failures in asyncio.

Practice checkpoint

Foundations · beginner · 5 min

Separate identity proof from session continuity and design browser authentication without exposing credentials or trusting client state.

Core concepts · intermediate · 5 min

Enforce access on individual resources, keep data separate from executable structure, and prevent sensitive values from crossing logging and build boundaries.

Applied patterns · intermediate · 6 min

Bind resource access to authenticated tenant membership instead of treating object identifiers as permission.

Production practice · advanced · 8 min

Separate cross-site request forgery from cross-origin response access and validate state changes.

Practice checkpoint

Foundations · beginner · 5 min

Design a predictable request and response contract by distinguishing resources, representations, safe methods, and retryable operations.

Core concepts · intermediate · 5 min

Keep list traversal stable, validate cached representations, and bound retry work when networks fail at ambiguous points.

Applied patterns · intermediate · 6 min

Use strong validators and atomic preconditions to prevent lost updates without confusing them with retry identity.

Production practice · advanced · 8 min

Use validators, Content-Range, and 416 handling to make partial downloads coherent.

Practice checkpoint

Foundations · beginner · 5 min

Distinguish compile-time guarantees from runtime data and use narrowing, discriminated unions, and explicit parsing at service boundaries.

Core concepts · intermediate · 5 min

Keep request handlers responsive by distinguishing asynchronous waiting from CPU work, bounding concurrency, and propagating stream failures.

Applied patterns · intermediate · 6 min

Parse unknown data and use discriminated unions to preserve operational meaning through callers.

Production practice · advanced · 8 min

Use for-await consumption, cancellation, and iterator return semantics without hiding queues.

Practice checkpoint

Foundations · beginner · 5 min

Separate source, build inputs, artifacts, and deployment configuration so the release you test is the release you actually operate.

Core concepts · beginner · 5 min

Design a release as a controlled change to code, configuration, and data, with explicit health checks and a recovery plan that matches what can actually be reversed.

Applied patterns · beginner · 10 min

Multi-stage builds keep the runtime image lean while preserving a fast developer loop. Learn how to separate build dependencies from runtime dependencies without losing traceability or reproducibility.

Production practice · beginner · 8 min

Build an operational view around user-visible latency, traffic, errors, and saturation instead of dashboards full of disconnected metrics.

Deep dives · intermediate · 7 min

Design CI stages, caches, artifacts, and test boundaries so a green pipeline means something and failures are quick to diagnose.

Deep dives · advanced · 17 min

Optimize Docker layers without breaking reproducibility, isolate CI execution, secure image provenance, and deploy compatible schema changes.

Deep dives · advanced · 17 min

Connect immutable infrastructure, safe schema evolution, IaC lock recovery, artifact provenance, and CI isolation into one release discipline.

Deep dives · intermediate · 5 min

Reconstruct a deployment incident without mistaking log delivery order or clock skew for causal ordering.

Deep dives · intermediate · 6 min

Give retries a stable business identity without confusing schedule windows with process start times.

Deep dives · advanced · 8 min

Reason about OIDC trust, token audience, job identity, and short-lived cloud credentials.

Practice checkpoint

Foundations · beginner · 8 min

Understand users, groups, permission bits, file descriptors, and redirection so shell and service behavior is easier to debug.

Core concepts · beginner · 9 min

Compose Unix text tools with explicit input, quoting, exit-status handling, and safe edits instead of treating pipelines as magic.

Applied patterns · beginner · 9 min

A root-cause workflow for shell failures involving quoting, pipelines, unset variables, traps, temporary files, and partial work.

Production practice · intermediate · 11 min

Diagnose connection failures by separating DNS, routing, transport, listening sockets, and application protocol behavior.

Deep dives · beginner · 8 min

Unix is full of tiny control primitives. Learn how `set -o pipefail`, process signals, and clean lifecycle management keep shell pipelines reliable and debuggable.

Deep dives · intermediate · 7 min

Follow signals from a container stop through shell wrappers and child processes, and build shutdown behavior that preserves work.

Deep dives · intermediate · 9 min

Separate resolver configuration, caching, search domains, authoritative records, and application-level DNS behavior.

Deep dives · intermediate · 9 min

Diagnose ENOSPC when disk usage looks confusing, including exhausted inodes and deleted files still held open.

Deep dives · advanced · 18 min

Connect kernel readiness APIs, resource limits, cgroups, socket queues, page cache, and inode behavior to production symptoms.

Deep dives · intermediate · 5 min

Build a bounded investigation pipeline that preserves malformed records and avoids lexical sorting across mixed offsets.

Deep dives · intermediate · 6 min

Separate atomic visibility from crash durability when publishing local files.

Deep dives · advanced · 8 min

Trace what survives fork and exec, and close capabilities a child should not inherit.

Practice checkpoint

Foundations · beginner · 5 min

Understand what the API stores, why controllers replace Pods, and how labels connect workloads without treating a cluster as a remote shell.

Core concepts · beginner · 5 min

Connect replaceable Pods through stable Services and reason about configuration, credentials, namespaces, and workload API permissions.

Applied patterns · beginner · 8 min

Learn how desired state, API objects, and controller loops turn declarative manifests into running workloads.

Production practice · intermediate · 10 min

Deployments are easy to start and hard to trust. Learn how readiness probes, rollout strategies, and traffic shaping keep Kubernetes services stable during real releases.

Deep dives · intermediate · 8 min

Connect pod resource requests and limits to scheduling, throttling, eviction risk, and Horizontal Pod Autoscaler behavior.

Deep dives · advanced · 18 min

Trace service traffic, prevent rollout 502s, debug CPU throttling and CoreDNS, and design conflict-safe controller reconciliation.

Deep dives · intermediate · 5 min

Operate a scheduled report as a reconciled workload with explicit timezone, lateness limits, and application-level deduplication.

Deep dives · intermediate · 6 min

Understand eviction admission, readiness accounting, and why a drain can correctly refuse to proceed.

Deep dives · advanced · 8 min

Follow deletion timestamps and controller-owned finalizer removal without hiding leaked resources.

Practice checkpoint

Foundations · beginner · 9 min

Separate consistency guarantees from delivery guarantees and design for the partial failures that make retries necessary.

Core concepts · intermediate · 12 min

Consumer groups are the mechanism that turns Kafka partitions into scalable, failure-tolerant work units. Learn how rebalances, offsets, and lag interact under load before you ship your first serious pipeline.

Applied patterns · advanced · 9 min

Learn why network retries create duplicate effects and how idempotency keys and an outbox close common reliability gaps.

Production practice · advanced · 18 min

Design around Kafka group churn, payment idempotency, coordination limits, sagas, CQRS, and context propagation across async boundaries.

Deep dives · advanced · 15 min

Reason about leader election across partitions and preserve causal context across Kafka, thread pools, and service boundaries.

Deep dives · advanced · 5 min

Design a minute-level dashboard that tolerates delayed events without treating a watermark as proof that every event arrived.

Deep dives · advanced · 6 min

Protect a shared resource from stale owners instead of assuming expired leases stop processes.

Deep dives · advanced · 8 min

Distinguish event causality from wall-clock order with Lamport and vector clocks.

Practice checkpoint

Foundations · beginner · 10 min

Learn tables, keys, constraints, joins, transactions, and query shape before choosing a specific database engine.

Core concepts · intermediate · 10 min

Connect PostgreSQL's multi-version concurrency control to transaction visibility, vacuum work, index choice, and EXPLAIN output.

Applied patterns · intermediate · 9 min

Understand InnoDB's clustered primary key, secondary-index lookups, transaction behavior, and practical query-plan analysis.

Production practice · intermediate · 10 min

Use Oracle analytic SQL for ordered calculations, inspect plan operations, and understand why bind-variable behavior matters.

Deep dives · intermediate · 10 min

Build common analytics queries while avoiding duplicate rows, incorrect aggregates, unstable pages, and cross-dialect surprises.

Deep dives · intermediate · 10 min

Choose between distinct salary ranking, row ranking, and pagination syntax while handling ties and NULLs explicitly.

Deep dives · intermediate · 9 min

Compare database routines and triggers with application services, focusing on transaction ownership, portability, and operational visibility.

Deep dives · advanced · 10 min

Understand transaction conflicts, lock waits, isolation anomalies, and safe retry boundaries across relational databases.

Deep dives · intermediate · 10 min

A systematic approach to diagnosing ORM query explosions and slow database plans without guessing at indexes.

Deep dives · advanced · 19 min

Reason about isolation anomalies, query-plan mistakes, B-tree/LSM trade-offs, shard routing, and production-safe index changes.

Deep dives · intermediate · 5 min

Investigate missing heartbeats with PostgreSQL interval arithmetic and a separate SQLite integer-millisecond contract.

Deep dives · intermediate · 6 min

Use a unique ordering tuple and a deliberate visibility policy for reliable page traversal.

Deep dives · advanced · 8 min

Use concurrent index builds without assuming they are lock-free or all-or-nothing.

Practice checkpoint