All Courses
Browse our entire catalog of individual engineering lessons. Prefer a structured approach? Check out our Learning Paths.
Algorithms: Sorting & Searching
Learn how to efficiently find data and organize it using foundational algorithms.
Operating Systems: Processes & Threads
Demystify what happens under the hood when your code actually runs on a CPU.
Computer Networks: The Internet
Explore the protocols that power the web, from IP addresses to HTTP.
Stacks & Queues
Understand LIFO vs FIFO structures and how they power function calls and task scheduling.
Hash Tables & Dictionaries
Learn how Hash Functions enable magical O(1) lookups using key-value pairs.
Trees & BSTs
Understand hierarchical data structures and O(log N) tree traversal.
Heaps & Priority Queues
Master Min-heaps and Max-heaps for priority-based task scheduling.
Graphs & Networks
Learn how Nodes and Edges model real-world networks like social media and GPS.
Tries & Prefix Trees
Store and search strings efficiently with trie data structures for autocomplete, spell check, and prefix matching.
Segment Trees
Perform range queries and updates in O(log N) time using segment trees for competitive programming and databases.
Fenwick Trees (BIT)
Compute prefix sums and range queries efficiently using bitwise operations.
Disjoint Set (Union-Find)
Track connected components dynamically using path compression and union by rank.
Skip Lists
Understand probabilistic data structures that provide O(log N) search as an alternative to balanced trees.
B-Trees & B+ Trees
Learn how B-trees and B+ trees power database indexes and file systems with disk-optimized multi-way branching.
Red-Black Trees
Study red-black tree invariants, rotations, and insertions that guarantee O(log N) balanced operations.
Recursion & Backtracking
Learn how functions that call themselves solve complex problems by breaking them down.
Divide & Conquer
Master algorithms like Merge Sort and Quick Sort that conquer big data by repeatedly halving it.
Dynamic Programming
Optimize heavy algorithms by storing and reusing solutions to overlapping subproblems.
Graph Traversal
Navigate connected node graphs using Breadth-First and Depth-First Search.
Greedy Algorithms
Solve optimization problems by making the locally optimal choice at every step.
Topological Sort
Order vertices in a directed acyclic graph using topological sort for dependency resolution and task scheduling.
Strongly Connected Components
Find strongly connected components in directed graphs with Tarjan's and Kosaraju's algorithms.
Minimum Spanning Trees
Compute minimum spanning trees with Kruskal's and Prim's algorithms for network design and clustering.
Shortest Path Algorithms
Find shortest paths with Dijkstra's, Bellman-Ford, and Floyd-Warshall algorithms for weighted graphs.
Maximum Flow (Ford-Fulkerson)
Solve maximum flow problems using Ford-Fulkerson and Edmonds-Karp for network capacity optimization.
String Matching (KMP)
Search for patterns in text efficiently with the KMP algorithm and its failure function preprocessing.
Computational Geometry Basics
Explore computational geometry: convex hulls, line intersection, point-in-polygon, and sweep line algorithms.
Memory Management & Paging
Learn how the OS tricks programs into thinking they have infinite memory.
File Systems & Storage
Understand block storage, formatting, and how operating systems organize vast oceans of bits.
Deadlocks & Synchronization
Master Mutexes, Semaphores, and preventing gridlock when multiple threads compete for resources.
The Memory Hierarchy
Understand the tradeoff between speed and size: from CPU registers to L1/L2 caches, RAM, and disk storage.
Garbage Collection & Memory Leaks
Explore how high-level languages automatically free memory using Reference Counting and Mark-and-Sweep.
System Calls
Dive into User Space vs. Kernel Space and how applications request hardware resources.
Inter-Process Communication
Learn how completely isolated processes talk to each other safely using Pipes and Sockets.
Shared Memory & Mapped Files
Bypass typical IPC bottlenecks by mapping files directly into RAM with mmap.
Signals & Interrupts
Control the chaotic lifecycle of processes by catching and handling async signals like SIGINT and SIGKILL.
Threading with pthreads
Dive into low-level multiprocessing using the POSIX thread library.
The OSI Model
The 7 structural layers of the internet, isolating abstract apps from raw electrical signals.
Transport Layer: TCP vs UDP
Examine the trade-off between guaranteed delivery and raw speed.
IP Addressing & Subnets
How IPv4 and IPv6 allocate massive address spaces, and how subnets filter traffic.
Network Security & TLS
Securing data in transit with encryption.
Symmetric vs Asymmetric Encryption
The mathematical backbone of modern internet privacy and secure data exchange.
Diffie-Hellman Key Exchange
How two computers can agree on a shared secret over a completely public, compromised channel.
The Full TLS Handshake
The exact millisecond-by-millisecond process of establishing a secure HTTPS web connection.
Digital Signatures & Certificates
How your browser actually knows that bank.com is run by the bank, and not a Russian hacker.
OAuth 2.0 & OpenID Connect
How 'Log in with Google' securely delegates access without handing over your password.
Web Vulnerabilities (XSS, CSRF, SQLi)
Deconstructing the top 3 ways applications get hacked, and how to programmatically fix them.
Zero Trust Architecture
Why the classic 'Castle-and-Moat' corporate firewall and VPN model is completely obsolete.
CPU Architecture & Caching
Identify how hardware processes code and handles immense disparities in read/write latency.
Distributed Systems Basics
Scaling massive applications across hundreds of computers simultaneously.
Databases: Relational vs NoSQL
Deciding the absolute best backend engine to power your web product.
ACID Transactions Deep Dive
Master Database Isolation Levels and understand how to prevent dirty reads and phantom data.
Database Indexing & B-Trees
How databases instantly search billions of rows using algorithmic data structures.
Query Optimization
Investigate how the SQL Engine translates your query into a physical Execution Plan.
Document Stores Deep Dive
Explore MongoDB, Schema-less design, and when to embed vs reference documents.
Key-Value & Graph DBs
Analyze extreme use cases: Redis for memory caching and Neo4j for social networks.
CAP Theorem In Practice
Master Eventual Consistency, Quorums, and exactly how major systems handle node failures.
Database Sharding & Replication
How to split a 50 Terabyte database seamlessly across 50 individual servers.
Logic Gates & Boolean Algebra
How abstract True/False statements map to physical silicon transistors.
Assembly & Machine Code
Explore the bridge between high-level Python and the pure binary a CPU understands.
Compilers vs Interpreters
How modern languages are translated so a CPU can execute them.
Theory of Computation
Turing Machines and the mathematical limits of what a computer can fundamentally solve.
The P vs NP Problem
The million-dollar unproven question that underpins modern encryption.
Virtualization & Containers
Understand Hypervisors, VMs, and the Docker container revolution.
Cryptography Foundations
Hashing, Salting, and the strict difference between Encoding and Encrypting.
Lexical Analysis (Scanner)
How a compiler turns raw text strings into a stream of meaningful Tokens.
Parsing & Abstract Syntax Trees (AST)
How tokens are arranged into a hierarchical tree representing grammatical structure.
Semantic Analysis & Type Checking
Ensure code actually makes logical sense through type safety and scoping.
Intermediate Representation (IR)
Translate the AST into a universal, machine-neutral code format like LLVM IR.
Code Optimization
How compilers rewrite your inefficient code to execute drastically faster.
Code Generation
The final step: translating IR down to physical hardware binary registers and opcodes.
Just-In-Time (JIT) Compilation
How modern VMs compile code dynamically during runtime to hyper-optimize based on actual usage.
Version Control: Git Internals
Demystifying what a commit actually is and how Git saves code history with trees and blobs.
API Design & REST
How to craft scalable interfaces for backends using statelessness and HTTP verbs.
System Design: Caching
Implementing Redis to survive massive traffic spikes using smart eviction policies.
Message Queues & Event-Driven
Decoupling systems using async queues like Kafka and RabbitMQ.
Microservices vs Monoliths
The trade-offs inherent in moving from a single unified codebase to thousands of separated APIs.
Testing: Unit, Integration, E2E
Guarding against regressions using the Test Automation Pyramid.
CI/CD Pipelines
Continuous Integration and Continuous Deployment for rapid, predictable code releases.
Web Security Foundations
Identifying and mitigating common vulnerabilities: XSS, CSRF, and SQLi.
Functional Programming
Embrace immutability and pure functions to write predictable and thread-safe code.
Object-Oriented Design
Master Encapsulation, Inheritance, and Polymorphism to structure large application codebases.
SOLID Principles
Write highly maintainable software using the 5 essential rules of object-oriented design.
Creational Patterns
Control object creation effectively using Singleton, Factory, and Builder patterns.
Structural Patterns
Connect incompatible systems seamlessly using Adapters, Facades, and Decorators.
Behavioral Patterns
Manage complex state and reactive event-driven logic with Observers and State patterns.
Dependency Injection
Decouple services completely, making your application mockable and relentlessly testable.
Clock Synchronization & Timestamps
How thousands of globally scattered computers agree on the exact sequence of events.
Consensus Algorithms (Raft)
How leaderless nodes democratically elect a dictator and guarantee perfectly mirrored data.
MapReduce & Distributed Processing
Processing 5 Petabytes of raw data using thousands of cheap commodity computers.
Streaming Architecture (Kafka)
Moving from slow, overnight batch processing to millions of real-time streaming events.
Microservices vs Monoliths
The massive pros and devastating cons of slicing applications into thousands of tiny servers.
API Gateways & Service Mesh
How to physically route millions of dynamic user requests to 5,000 shifting containers.
Message Queues & Pub/Sub
Decoupling aggressive traffic spikes via asynchronous background workers.
Content Delivery Networks (CDNs)
Bypassing the speed of light by geographically caching massive assets on the edge.
Machine Learning Basics
The mathematical shift from hard-coded rules to algorithmically derived patterns.
Neural Networks & Deep Learning
How mimicking the biological brain scales feature abstraction to solve impossible problems.
Quantum Computing Foundations
Shattering classical binary logic with Superposition and Entanglement.
The Future of Compute
The physical limits of Moore's Law and the profound paradigm shifts on the horizon.
Linear Regression: Finding the Line
Understand how linear regression finds the best-fit line through data points.
Python Data Stack: Pandas & NumPy
Master the essential tools for data manipulation: DataFrames and arrays.
Classification: Predicting Categories
Learn how to predict categories (like churn vs. retention) using Logistic Regression with Scikit-Learn.
Evaluating Models: Train & Test Splits
Learn how to evaluate your models accurately and prevent overfitting by splitting your data.
Generative AI Foundations
Understand how Large Language Models (LLMs) process text as tokens and learn to estimate inference costs.
Support Vector Machines (SVM)
Learn how SVMs find the optimal mathematical boundary between different classes of data.
Model Tuning & Cross-Validation
Take your models to the next level by systematically finding the best hyperparameters.
The Transformer Architecture
Explore the groundbreaking architecture that powers ChatGPT, Claude, and modern AI.
Advanced Prompt Engineering
Master techniques like Few-Shot prompting and Chain of Thought to get better results from LLMs.
Retrieval-Augmented Generation (RAG)
Learn how to give AI models access to custom documents and real-time knowledge.
Data Preprocessing & Cleaning
Learn to handle missing data, drop duplicates, and prepare clean datasets.
Exploratory Data Analysis (EDA)
Group data, understand distributions, and uncover hidden insights.
Feature Engineering
Create new features and encode text so ML models can understand them.
Decision Trees & Ensembles
Learn how algorithms can make decisions through a series of yes/no questions, and how Random Forests combine them.
Unsupervised Learning (Clustering)
Group similar data points together without knowing the answers beforehand using K-Means.
Probability & Statistics
Master the mathematical language of uncertainty that powers all machine learning models.
Math for ML: Vectors & Matrices
Explore the core linear algebra operations that make neural networks and embeddings possible.
PCA & Dimensionality Reduction
Learn how to compress hundreds of features into their most important components.
Naive Bayes & NLP Basics
Use probability to classify text and build a classic spam filter.
Reinforcement Learning (RL)
Teach an AI to play games by maximizing rewards using Q-Learning.
AI Agents & Tool Use
How modern LLMs function autonomously using external tools and reasoning loops.
Neural Networks 101: The Perceptron
Understand the biological inspiration behind AI: the artificial neuron.
Forward Propagation & Deep Networks
Stack neurons into layers to create Deep Neural Networks capable of complex logic.
Loss Functions & Evaluation
Learn how networks measure how 'wrong' their predictions are.
Gradient Descent & Backpropagation
Understand the mathematical engine that actually allows Neural Networks to learn.
Optimizers: Beyond Vanilla Descent
Why nobody uses standard Gradient Descent, and how advanced Optimizers speed up training.
Training Loops in PyTorch
Write the standard 5-step PyTorch training loop used by researchers worldwide.
Regularization, Dropout & BatchNorm
Prevent networks from memorizing the data using Regularization layers.
Convolutional Neural Networks (CNNs)
How AI processes visual data using Convolutions and Pooling.
Recurrent Networks: RNNs & LSTMs
Processing sequential data like heartbeat signals, stock prices, and text.
Autoencoders & Latent Spaces
Compressing reality into vectors to build the foundation of Generative AI.
Gradient Boosting Machines
Learn how gradient boosting builds trees sequentially, each correcting errors of the previous one.
XGBoost in Practice
Master XGBoost: regularization, feature importance, handling missing values, and hyperparameter tuning.
LightGBM & Fast Training
Train models faster with LightGBM's histogram-based splits, leaf-wise growth, and categorical support.
CatBoost & Categorical Features
Use CatBoost for datasets with many categorical features without manual encoding.
Ensemble Stacking Techniques
Combine multiple models into a meta-learner using stacking to boost predictive performance.
Model Blending Strategies
Blend predictions from diverse models using weighted averaging and cross-validated blending strategies.
DBSCAN Clustering
Discover clusters of arbitrary shape with DBSCAN: density-based grouping without specifying K.
Gaussian Mixture Models
Model data as mixtures of Gaussian distributions for soft clustering and density estimation.
Hierarchical Clustering
Build hierarchical cluster trees (dendrograms) with agglomerative and divisive methods.
Evaluating Cluster Quality
Diagnose underfitting and overfitting by evaluating cluster models internally using Silhouette Scores.
t-SNE for Visualization
Visualize high-dimensional data in 2D/3D with t-SNE while preserving local neighborhood structure.
UMAP Dimensionality Reduction
Use UMAP for fast, scalable dimensionality reduction that preserves both local and global structure.
Anomaly Detection Methods
Detect outliers and anomalies with Isolation Forest, Local Outlier Factor, and statistical methods.
Autoencoders for Unsupervised Learning
Learn how autoencoders compress and reconstruct data for feature learning and anomaly detection.
Text Preprocessing for NLP
Clean and prepare text data: tokenization, stopword removal, stemming, lemmatization, and normalization.
Bag of Words & TF-IDF
Represent text as numerical vectors using bag-of-words, n-grams, and TF-IDF weighting.
Word Embeddings (Word2Vec)
Understand word embeddings: how Word2Vec, GloVe, and FastText capture semantic meaning in vectors.
Sequence Models for NLP
Apply recurrent models (RNNs, LSTMs, GRUs) to text tasks like translation and summarization.
Named Entity Recognition
Extract named entities (people, places, organizations) from text using sequence labeling models.
Sentiment Analysis
Build sentiment classifiers that determine whether text expresses positive, negative, or neutral opinions.
Text Classification Pipelines
Create end-to-end text classification pipelines: preprocessing, vectorization, training, and evaluation.
Image Preprocessing Techniques
Prepare images for model input: resizing, normalization, color space conversion, and batch loading.
Feature Extraction from Images
Extract visual features from images using traditional methods (HOG, SIFT) and CNN feature maps.
Object Detection Fundamentals
Detect and localize objects in images with anchor boxes, YOLO, and two-stage detector architectures.
Image Segmentation
Segment images at the pixel level with semantic, instance, and panoptic segmentation approaches.
Data Augmentation for Vision
Expand training datasets with augmentation: flipping, rotation, cropping, color jitter, and mixup.
Transfer Learning for Vision
Leverage pre-trained models (ResNet, EfficientNet) and fine-tune them for your specific vision task.
Face Recognition Systems
Build face recognition systems: face detection, alignment, embedding extraction, and identity matching.
Variational Autoencoders (VAEs)
Generate new data with Variational Autoencoders: latent space sampling, the ELBO loss, and interpolation.
GANs Introduction
Understand Generative Adversarial Networks: the generator-discriminator game and training dynamics.
Conditional GANs
Control GAN outputs with conditional generation: class-conditional, text-to-image, and style transfer.
Diffusion Models
Learn diffusion models: the forward noising process, reverse denoising, and modern architectures.
Text-to-Image Generation
Generate images from text prompts with models like Stable Diffusion: architecture, guidance, and fine-tuning.
Fine-Tuning Large Language Models
Fine-tune large language models on custom data: LoRA, QLoRA, instruction tuning, and dataset preparation.
RLHF & AI Alignment
Align AI models with human preferences using RLHF: reward modeling, PPO training, and evaluation.
Time Series Decomposition
Decompose time series into trend, seasonal, and residual components for better understanding and forecasting.
ARIMA Forecasting
Forecast stationary time series with ARIMA: differencing, autocorrelation, and parameter selection.
Prophet for Time Series
Use Facebook Prophet for automatic seasonality detection, holiday effects, and changepoint handling.
LSTMs for Forecasting
Apply LSTMs to time series forecasting: sequence windowing, multi-step predictions, and feature engineering.
Anomaly Detection in Time Series
Detect anomalies in time series data using statistical tests, sliding windows, and deep learning methods.
Multivariate Time Series
Model multiple correlated time series simultaneously with VAR, multivariate LSTM, and attention mechanisms.
Forecasting Pipelines
Build production forecasting pipelines: data ingestion, model training, prediction serving, and monitoring.
Experiment Tracking (MLflow)
Track ML experiments with MLflow: parameters, metrics, artifacts, and experiment comparison dashboards.
Model Versioning & Registry
Version models and manage the model registry for staging, production, and rollback across environments.
Feature Stores
Centralize feature computation and serving with feature stores for consistent training and inference.
Model Serving & APIs
Deploy models as REST APIs: model serialization, containerization, batching, and latency optimization.
A/B Testing for ML Models
Run A/B tests on ML models to measure real-world impact and make data-driven deployment decisions.
Monitoring Model Drift
Monitor models in production for data drift, concept drift, and performance degradation over time.
ML Pipeline Orchestration
Orchestrate ML pipelines with Airflow, Kubeflow, or Vertex AI for reproducible, automated workflows.
Graph Neural Networks
Apply neural networks to graph-structured data: node classification, link prediction, and graph generation.
Federated Learning
Train models across decentralized data sources without sharing raw data using federated learning.
Reinforcement Learning Deep Dive
Deep dive into RL: Q-learning, policy gradients, actor-critic methods, and environment design.
Multi-Agent Systems
Build systems where multiple AI agents collaborate or compete to solve complex tasks together.
Neural Architecture Search
Automatically discover optimal neural network architectures with NAS, DARTS, and efficiency-aware search.
Self-Supervised Learning
Learn representations from unlabeled data with self-supervised methods: contrastive learning and masking.
Few-Shot & Zero-Shot Learning
Generalize to new tasks with minimal examples using few-shot and zero-shot learning techniques.
Multimodal AI Models
Build models that process and combine multiple data types: text, images, audio, and video together.
AI Safety & Alignment
Understand AI safety challenges: alignment, interpretability, robustness, and value specification.
Efficient Inference Techniques
Speed up model inference with quantization, distillation, caching, and hardware-specific optimizations.
Model Compression & Pruning
Reduce model size with pruning, weight sharing, low-rank factorization, and knowledge distillation.
Edge AI Deployment
Deploy ML models to edge devices: mobile, IoT, and embedded systems with TensorFlow Lite and ONNX.
Responsible AI Practices
Build fair, transparent, and accountable AI systems with bias detection, explainability, and governance.
HTML Forms & Input Types
Master HTML forms: text inputs, selects, checkboxes, validation attributes, and form submission.
HTML Accessibility (a11y)
Build inclusive web pages with ARIA attributes, keyboard navigation, focus management, and screen reader best practices.
HTML Tables & Lists
Structure tabular data with accessible tables, and organize content with ordered, unordered, and description lists.
HTML Media & Embeds
Embed images, video, audio, and iframes with responsive sizing, lazy loading, and performance optimization.
CSS Selectors & Specificity
Master CSS selectors from basic to advanced, understand the specificity hierarchy, and learn the cascade.
CSS Box Model & Layout
Understand the CSS box model: content, padding, border, margin, and how box-sizing changes everything.
CSS Flexbox
Master one-dimensional layouts with Flexbox: alignment, wrapping, ordering, and responsive patterns.
CSS Grid
Build powerful two-dimensional layouts with CSS Grid: rows, columns, areas, and responsive patterns.
Responsive Design
Build layouts that adapt to any screen size using media queries, fluid typography, and mobile-first design.
CSS Transitions & Animations
Add motion to your UI with CSS transitions, keyframe animations, and performance-optimized transforms.
CSS Custom Properties (Variables)
Use CSS custom properties to create maintainable, themeable stylesheets with dynamic values.
Sass Preprocessing
Speed up CSS development with Sass: nesting, mixins, variables, partials, and inheritance.
BEM Methodology
Organize CSS with the BEM methodology: Block, Element, Modifier naming conventions for scalable styles.
CSS Architecture & Best Practices
Organize large CSS codebases with architecture patterns, file structure, and performance optimization.
JavaScript Variables & Types
Understand JavaScript variables (let, const, var), primitive types, type coercion, and typeof operator.
Operators & Control Flow
Control program flow with comparison operators, logical operators, if/else, switch, and ternary expressions.
Functions & Scope
Define and invoke functions, understand scope, hoisting, arrow functions, and default parameters.
JavaScript Arrays
Manipulate arrays with map, filter, reduce, find, sort, spread operator, and destructuring.
JavaScript Objects
Work with JavaScript objects: properties, methods, destructuring, spread/rest, and computed keys.
DOM Manipulation
Select, create, modify, and remove DOM elements using querySelector, createElement, and classList.
Event Handling & Delegation
Handle user interactions with addEventListener, event propagation, delegation, and custom events.
Async JavaScript & Promises
Master asynchronous JavaScript: callbacks, Promises, async/await, and Promise.all for concurrent operations.
Fetch API & HTTP Requests
Make HTTP requests with the Fetch API: GET, POST, headers, JSON parsing, and AbortController.
Error Handling & Debugging
Debug effectively with try/catch, custom error classes, console methods, and browser DevTools.
Closures & Lexical Scope
Understand closures, lexical scope, and how functions capture variables from their enclosing scope.
Prototypes & Classes
Learn JavaScript's prototype chain, ES6 classes, inheritance, static methods, and private fields.
JavaScript Modules (ES Modules)
Organize code with ES modules: import/export, named vs default exports, and dynamic imports.
Iterators & Generators
Use iterators and generators to create lazy sequences, custom iterables, and async generators.
Web APIs (Storage, Geolocation)
Explore browser Web APIs: localStorage, sessionStorage, Geolocation, Intersection Observer, and Clipboard.
TypeScript Introduction
Get started with TypeScript: installation, basic types, type annotations, and the compilation process.
TypeScript Types & Interfaces
Define shapes of data with TypeScript interfaces, type aliases, unions, intersections, and literal types.
TypeScript Generics
Write reusable code with TypeScript generics: generic functions, constraints, and generic components.
TypeScript Utility Types
Use built-in utility types like Partial, Required, Pick, Omit, Record, and ReturnType.
TypeScript Strict Mode & Config
Configure TypeScript strict mode, tsconfig.json options, and integrate TypeScript into existing projects.
React & JSX Fundamentals
Understand JSX syntax, React element creation, component rendering, and the React tree structure.
Components & Props
Build reusable UI pieces with React components, pass data via props, and compose component hierarchies.
State & useState Hook
Add interactivity with the useState hook: state updates, functional updates, and state lifting patterns.
Conditional Rendering
Render different UI based on conditions using ternaries, logical &&, early returns, and switch patterns.
Lists, Keys & Rendering Arrays
Render dynamic lists with .map(), understand why React needs keys, and handle list updates efficiently.
useEffect & Side Effects
Perform side effects with useEffect: data fetching, subscriptions, cleanup functions, and dependency arrays.
useContext & Shared State
Share state across components without prop drilling using React's Context API and useContext hook.
useReducer for Complex State
Manage complex state logic with useReducer: actions, dispatching, and when to prefer it over useState.
useRef & DOM Access
Access DOM elements and persist values across renders with useRef without triggering re-renders.
Custom Hooks
Extract and reuse stateful logic by building custom hooks for common patterns like data fetching and forms.
Component Composition Patterns
Build flexible UIs with composition patterns: children prop, compound components, and slot patterns.
Higher-Order Components
Enhance components with higher-order components (HOCs) for cross-cutting concerns like auth and logging.
Render Props Pattern
Share code between components using the render props pattern for maximum flexibility.
Error Boundaries
Catch JavaScript errors in React component trees with error boundaries and display fallback UIs.
React Portals & Modals
Render UI outside the component tree with React Portals for modals, tooltips, and floating elements.
React Router Setup
Set up client-side routing with React Router: Route, Link, and BrowserRouter configuration.
Dynamic Routes & Parameters
Handle dynamic URL parameters and query strings to build data-driven pages.
Nested Routes & Layouts
Create complex layouts with nested routes, shared layouts, and outlet-based composition.
Protected Routes
Guard routes based on authentication state and redirect unauthorized users to login.
Programmatic Navigation
Implement programmatic navigation, redirects, and browser history management in React apps.
State Lifting
Coordinate state between sibling components by lifting state to their nearest common ancestor.
Context API Advanced Patterns
Build scalable state management with the Context API: providers, consumers, and performance optimization.
Redux Toolkit
Set up Redux Toolkit with createSlice, configureStore, and async thunks for predictable state management.
Zustand State Management
Use Zustand for lightweight state management with a simple API, selectors, and middleware.
React Query (TanStack Query)
Manage server state with React Query: caching, background refetching, pagination, and optimistic updates.
React Forms & Validation
Build controlled and uncontrolled forms with validation, error handling, and React Hook Form.
React Performance Optimization
Optimize React rendering with memo, useMemo, useCallback, virtualization, and profiling tools.
Suspense & Lazy Loading
Code-split your React app with React.lazy, Suspense boundaries, and streaming server rendering.
Testing React Components
Test React components with React Testing Library: render, query, fire events, and test async behavior.
React Ecosystem & Best Practices
Navigate the React ecosystem: Next.js, UI libraries, animation tools, and production best practices.
CSS Modules in React
Scope styles to components with CSS Modules: local class names, composition, and build integration.
Tailwind CSS Fundamentals
Build modern UIs rapidly with Tailwind CSS utility classes, responsive prefixes, and component extraction.
Styled-Components & CSS-in-JS
Write component-scoped styles with styled-components: tagged templates, dynamic props, and theming.
Design Tokens & Theme Systems
Create consistent design systems with design tokens, theme providers, and centralized style configuration.
Responsive Components
Build components that adapt to any viewport with responsive props, container queries, and fluid typography.
REST Client Architecture
Design robust REST client layers with Axios or Fetch: interceptors, base URLs, and retry logic.
GraphQL Basics
Query APIs with GraphQL: schemas, queries, mutations, and client-side caching with Apollo or urql.
WebSockets & Real-Time
Build real-time features with WebSockets: connection lifecycle, events, and reconnection strategies.
Optimistic Updates
Implement optimistic UI updates and client-side caching for snappy, responsive data interactions.
API Error Handling
Handle API errors gracefully with retry logic, error boundaries, user-friendly messages, and fallback states.
Node.js Fundamentals
Understand Node.js fundamentals: the event loop, modules, npm, and building command-line tools.
Express.js Routing
Build RESTful APIs with Express.js: route handlers, path parameters, query strings, and response methods.
Express Middleware
Write Express middleware for logging, authentication, CORS, body parsing, and request validation.
Express Error Handling
Implement centralized error handling in Express with error middleware, status codes, and error responses.
Node.js File System & Streams
Read and write files, work with streams, and handle file paths in Node.js server applications.
SQL Fundamentals
Write SQL queries: SELECT, INSERT, UPDATE, DELETE, JOINs, GROUP BY, and aggregate functions.
PostgreSQL Deep Dive
Use PostgreSQL for production apps: data types, indexes, constraints, transactions, and full-text search.
MongoDB & NoSQL
Model data with MongoDB: documents, collections, queries, indexes, and aggregation pipelines.
ORMs with Prisma
Use Prisma ORM to define schemas, generate type-safe queries, and manage database relationships.
Database Migrations
Keep your database schema in sync with your code using migrations, seed scripts, and rollback strategies.
JWT Authentication
Implement stateless authentication with JSON Web Tokens: signing, verifying, refresh tokens, and storage.
OAuth2 & Social Login
Add social login to your app with OAuth2 flows: Google, GitHub, and third-party identity providers.
Sessions & Cookies
Manage user sessions with cookies, server-side session stores, and session configuration.
Role-Based Access Control
Implement role-based access control (RBAC) to restrict routes and features based on user permissions.
Password Security
Secure passwords with bcrypt hashing, salting, and best practices for credential storage.
Unit Testing with Vitest
Write unit tests with Vitest: test suites, assertions, mocking, and code coverage.
React Testing Library
Test React components with React Testing Library: rendering, querying, user events, and async testing.
Integration Testing
Write integration tests that verify multiple components and API layers work together correctly.
E2E Testing with Playwright
Automate browser testing with Playwright: page navigation, selectors, assertions, and test fixtures.
Test-Driven Development
Practice test-driven development: write failing tests first, implement code, then refactor with confidence.
Git Workflows
Manage code with Git: branches, merge strategies, rebasing, pull requests, and conflict resolution.
CI/CD Pipelines
Automate build, test, and deploy workflows with CI/CD pipelines using GitHub Actions.
Docker for Web Apps
Containerize web applications with Docker: Dockerfiles, multi-stage builds, and docker-compose.
Cloud Deployment
Deploy full-stack apps to the cloud with Vercel, AWS, or similar platforms with custom domains and SSL.
Performance Monitoring
Monitor web application performance with Lighthouse, Core Web Vitals, bundle analysis, and real-user metrics.
The CAP Theorem
Understand the CAP theorem: consistency, availability, partition tolerance, and real-world trade-offs.
Consistency Models
Compare consistency models: strong, eventual, causal, and linearizable consistency.
Distributed Clocks & Ordering
Solve ordering problems with logical clocks, vector clocks, and hybrid logical clocks.
Consensus Algorithms
Understand consensus: Paxos, Raft, and how distributed systems agree on shared state.
TCP/IP Deep Dive
Understand TCP/IP: the protocol stack, connection lifecycle, flow control, and congestion management.
HTTP/2 & HTTP/3
Understand HTTP evolution: multiplexing, server push, header compression, and QUIC protocol.
DNS Architecture
Understand DNS: hierarchical resolution, caching, record types, and DNS-based load balancing.
Load Balancing Strategies
Distribute traffic with load balancing: round-robin, least connections, consistent hashing, and health checks.
Content Delivery Networks
Accelerate content delivery with CDNs: edge caching, cache invalidation, and global distribution.
Monoliths vs Microservices
Evaluate when to use monolithic vs microservice architectures and understand their operational trade-offs.
Service Meshes
Learn how service meshes handle traffic management, observability, and security between microservices.
API Gateway Design
Design API gateways for authentication, rate limiting, request routing, and protocol translation.
gRPC & Protocol Buffers
Build efficient inter-service communication with gRPC, Protocol Buffers, and streaming RPCs.
Message Queues
Decouple services with message queues: RabbitMQ, Kafka, pub/sub patterns, and dead letter queues.
Event-Driven Architecture
Build event-driven systems with event sourcing, CQRS, and domain events for loosely coupled services.
Idempotency & Retries
Design idempotent APIs that safely handle retries, duplicate messages, and network failures.
Circuit Breaker Pattern
Prevent cascade failures with circuit breakers: closed, open, half-open states and failure thresholds.
Distributed Tracing
Debug distributed systems with tracing: spans, trace context propagation, and OpenTelemetry.
Backpressure & Flow Control
Handle overload with backpressure: rate limiting, buffering, dropping, and reactive streams.
Caching Strategies
Choose the right caching strategy: cache-aside, write-through, write-behind, and read-through patterns.
Redis Deep Dive
Master Redis: data structures, pub/sub, Lua scripting, persistence, and high-availability clusters.
Cache Warming & Stampede
Prevent cache stampede with locking, probabilistic early expiration, and cache warming strategies.
Cache Invalidation
Tackle cache invalidation: TTL-based, event-driven, version-based, and tag-based strategies.
Consistent Hashing
Scale caching across nodes with consistent hashing, virtual nodes, and minimal key redistribution.
Database Replication
Set up database replication: leader-follower, multi-leader, and leaderless patterns for availability.
Database Sharding
Partition data across database instances with range-based, hash-based, and geographic sharding.
Write-Ahead Logging
Ensure durability with write-ahead logs: crash recovery, log compaction, and checkpointing.
Database Indexing Internals
Understand index internals: B-trees, LSM trees, hash indexes, and when to use each.
Connection Pooling
Manage database connections efficiently with connection pools, pool sizing, and connection lifecycle.
Linux Fundamentals
Master Linux for systems engineering: process management, file systems, permissions, and system monitoring.
Networking Fundamentals
Understand networking: subnets, CIDR, firewalls, NAT, VPNs, and network troubleshooting.
Infrastructure as Code
Manage infrastructure with code using Terraform: providers, resources, state, and modules.
Configuration Management
Manage server configuration with Ansible: playbooks, roles, inventory, and idempotent tasks.
Docker Internals
Understand Docker internals: namespaces, cgroups, union filesystems, and container isolation.
Dockerfile Best Practices
Write production Dockerfiles: multi-stage builds, layer caching, security, and small images.
Container Networking
Configure container networking: bridge networks, overlay networks, DNS resolution, and port mapping.
Container Security
Secure containers: read-only filesystems, non-root users, resource limits, and image scanning.
Container Orchestration Concepts
Understand orchestration concepts: scheduling, scaling, self-healing, and service discovery.
Kubernetes Architecture
Understand Kubernetes architecture: control plane, nodes, pods, and the reconciliation loop.
Pods & Deployments
Master K8s workloads: pods, deployments, ReplicaSets, rolling updates, and rollbacks.
Services & Ingress
Expose K8s workloads: ClusterIP, NodePort, LoadBalancer, and Ingress controllers.
ConfigMaps & Secrets
Externalize configuration: ConfigMaps for settings, Secrets for sensitive data, and environment injection.
Helm Charts
Package K8s applications with Helm: charts, templates, values, releases, and chart repositories.
Horizontal Pod Autoscaling
Auto-scale K8s workloads: HPA, VPA, CPU/memory metrics, custom metrics, and scaling policies.
Persistent Volumes
Manage storage in K8s: PersistentVolumes, PersistentVolumeClaims, StorageClasses, and stateful workloads.
Kubernetes Operators
Extend K8s with custom operators: CRDs, controllers, and the operator pattern for complex applications.
AWS Core Services
Navigate AWS core services: EC2, S3, RDS, Lambda, VPC, and IAM for cloud infrastructure.
Cloud Networking (VPC)
Design cloud networks: VPC, subnets, route tables, security groups, NACLs, and peering.
Serverless Architecture
Build with serverless: Lambda, API Gateway, event triggers, cold starts, and serverless patterns.
CI/CD Fundamentals
Build CI/CD pipelines: continuous integration, delivery, deployment, and pipeline design patterns.
GitHub Actions
Automate workflows with GitHub Actions: triggers, jobs, matrix builds, caching, and reusable actions.
Deployment Strategies
Deploy safely: blue-green, canary, rolling updates, A/B testing, and feature flags.
Structured Logging
Implement structured logging: JSON format, correlation IDs, log levels, and centralized log aggregation.
Metrics & Monitoring
Monitor systems with metrics: Prometheus, Grafana, RED/USE methods, and alerting strategies.
Alerting & On-Call
Design effective alerting: SLOs, error budgets, alert fatigue prevention, and on-call practices.
Incident Management
Handle incidents effectively: severity levels, incident response, post-mortems, and blameless culture.
Chaos Engineering
Test resilience with chaos engineering: fault injection, game days, and building confidence in system behavior.
Security Fundamentals
Secure distributed systems: zero trust, TLS/mTLS, secrets management, and defense in depth.
Performance Optimization
Optimize system performance: profiling, bottleneck analysis, database tuning, and capacity planning.
The Operating System Kernel
Understand the OS kernel: user space vs kernel space, system calls, and rings of privilege.
Process Memory Layout
Understand how memory is structured: Text, Data, Heap, and Stack segments.
CPU Scheduling
Learn how the OS shares the CPU: context switching, Round Robin, and Completely Fair Scheduler (CFS).
Virtual Memory & Paging
Understand virtual memory, page tables, the MMU, page faults, and swapping.
Inter-Process Communication (IPC)
Learn how processes talk: Pipes, Sockets, Signals, and Shared Memory.
Threads vs Processes
Concurrency models: why threads are cheaper, shared memory, and the Global Interpreter Lock (GIL).
Synchronization: Mutexes
Solve race conditions: Critical sections, Mutexes, Locks, and Semaphores.
Concurrency: Deadlocks
Understand the ultimate concurrency bug: Deadlocks, Coffman conditions, and deadlock prevention.
Asynchronous I/O
Understand non-blocking I/O: epoll, kqueue, the Event Loop, and the C10K problem.
File Systems Internals
Deep dive into disks: blocks, inodes, symlinks vs hardlinks, and journaled file systems (ext4).
Transactions & ACID
Understand database transactions: Atomicity, Consistency, Isolation, and Durability.
Isolation Levels
Navigate transaction isolation: Dirty Reads, Non-Repeatable Reads, Phantom Reads, and Serializable.
MVCC (Multi-Version Concurrency)
How databases use MVCC to allow lock-free reads while transactions write concurrently.
Distributed Transactions
Solve transactions across microservices using Two-Phase Commit (2PC) and Saga Patterns.
Consensus & Leader Election
Understand distributed consensus algorithms: Paxos, Raft, brain split, and leader election.
Distributed Locks & Leases
Synchronize distributed systems using Redis Redlock, ZooKeeper, and Leases.
Dynamo Architecture
NoSQL deep dive: DynamoDB/Cassandra, fully decentralized databases, Gossip, and Quorums.
Spanner & NewSQL
Understand Google Spanner: combining NoSQL scalability with SQL ACID via atomic clocks (TrueTime).
Time-Series Databases
Storing metric data efficiently: Time-Series DBs (TSDB), InfluxDB, Gorilla compression.
Search & Vector Databases
Understand inverted indices (Elasticsearch) and Vector Embeddings (Pinecone) for AI search.
Message Brokers vs Streaming
Understand the difference between Message Queues (RabbitMQ) vs Event Streams (Kafka).
RabbitMQ & AMQP
Understand Advanced Message Queuing Protocol: Exchanges, Queues, and Routing Keys.
Kafka Architecture
Dive into Apache Kafka: Topics, Partitions, Brokers, and Zero-Copy I/O.
Consumer Groups & Offsets
Master Kafka consumer scaling: Groups, Rebalancing, and committing offsets.
Exactly-Once Semantics
The hardest problem in streaming: At-Most-Once, At-Least-Once, and Exactly-Once Semantics (EOS).
Event Sourcing
Architect systems using Event Sourcing: storing state as a sequence of immutable events.
CQRS Architecture
Scale reads and writes independently using Command Query Responsibility Segregation (CQRS).
WebSockets & SSE
Real-time communication protocols: WebSockets vs Server-Sent Events vs Long Polling.
WebRTC
Understand WebRTC and Peer-to-Peer communication for ultra low-latency video and audio.
Stream Processing
Process endless data with Apache Flink, Spark Streaming, Stateful operators, and Time Windows.
Rate Limiting Algorithms
Protect APIs using Token Bucket, Leaky Bucket, and Sliding Window Rate Limiting.
Distributed ID Generation
Generate unique, sortable IDs across distributed servers using Twitter Snowflake.
Probabilistic Data Structures
Process massive datasets efficiently using Bloom Filters and HyperLogLog.
Spatial Indexing (Geohash)
Design Uber/Yelp architectures: Geohashes, QuadTrees, and spatial databases.
CRDTs & Real-Time Collab
Learn how Google Docs / Figma synchronize state collaboratively without locks using CRDTs.
Data Synchronization (Merkle Tree)
Find out how databases detect desynchronization efficiently using Merkle Trees (Anti-Entropy).
Distributed Job Scheduling
Cron at scale: Design a system to execute 1 million delayed tasks precisely on time.
Backpressure & Load Shedding
Keep systems alive during 100x traffic spikes: Backpressure, Circuit Breakers, and Load Shedding.
System Design: Chat App
Put it all together: Design a WhatsApp/Discord architecture using WebSockets and PubSub.
System Design: Video Streamer
The grand finale: Design YouTube/Netflix architecture. CDNs, Transcoding pipelines, and Scale.