Practice MCQs

A/B testing evaluates user responses to different versions of a webpage or app

Learn about Adaptive Bitrate Streaming and its key components

A comprehensive guide to understanding analytics pipelines and their components

Audit tables provide a tamper-proof record of system actions

Learn the fundamentals of asynchronous job processing and message queues

Explore the fundamentals of asynchronous processing pipelines in software development

Explore the architecture and mechanisms behind audio streaming technologies

Learn the fundamentals of authentication and authorization in web applications

Understanding authorization and role-based access control for secure applications

Caching improves application performance by storing frequently accessed data temporarily

Explore canvas rendering techniques for efficient graphics and animations

Quick estimations for system design feasibility before coding

Globally distributed networks caching content at edge nodes near users for speed and scale

Prevent cascading failures by stopping requests to failing dependencies and fast-failing instead.

Store data locally in the browser to eliminate redundant network requests and improve app performance

Distributes keys across nodes with minimal reshuffling on topology changes

Conflict-free data structures enabling real-time collaborative editing without central coordination.

Enable multiple browser tabs to synchronize state and communicate in real time

Database constraints enforce data integrity rules that survive application bugs and multiple entry points.

Database indexes accelerate query lookups using B-Tree structures, balancing read speed against write cost

Master database relationships, foreign keys, and referential integrity for normalized schemas

Core database concepts covering relational and non-relational storage, indexing, transactions, and distributed patterns.

Safety nets for failed messages in distributed systems using queues

Master message delivery guarantees and build idempotent consumers for reliable distributed systems

Synchronize distributed systems by transmitting only data changes, not full state

Build fast, reliable payment systems handling money flow across distributed services safely

Master drag-and-drop interaction design from raw browser APIs to production libraries.

Build secure end-to-end encrypted notes using Web Crypto API in the browser

Distribute computation and caching globally to reduce latency and improve user experience

Design patterns, constraints, and safety mechanisms for embedded microcontroller systems

Software design pattern enabling system components to communicate asynchronously through events

Retry failed requests with exponentially increasing delays and randomization to improve resilience.

Learn failure modes in distributed systems and resilience patterns

Read, write, and manage files in the browser using File API and File System Access API

Store files efficiently by content hash while maintaining security, privacy, and safe deletion.

Organizing frontend code through proven patterns for maintainability, scalability, and team collaboration

Master browser Geolocation and Permissions APIs to build location-aware web apps responsibly

Query locations using latitude, longitude, and distance calculations on Earth's surface

Design systems to work partially when components fail instead of crashing completely

Build interactive draggable dashboards using flexbox, grid, and react-grid-layout

Make non-idempotent operations safe to retry using unique keys and server-side deduplication

Low-level browser API for storing large structured data with transactions and indexes

Load large datasets incrementally using pagination and infinite scroll patterns

Browser API for detecting element visibility changes without polling or layout thrashing

Determining user location and locale from IP addresses to serve localized content.

Distributed event streaming platform for high-throughput, fault-tolerant real-time data pipelines

Resolves simultaneous writes by keeping the one with the highest timestamp

Load images only when needed to improve page performance and user experience

Render only visible items to handle thousands of DOM nodes efficiently

Distributes incoming traffic across multiple servers to prevent overload and ensure availability

Message queues decouple services, enable asynchronous processing, and improve system resilience.

Store and retrieve files at scale using S3-compatible object storage systems

Understand system observability through logs, metrics, traces, and retention strategies

Design applications that function offline by prioritizing local storage and syncing when reconnected

Physical devices that function offline, sync transactions safely, and maintain security when reconnected

Technology enabling concurrent multi-user document edits through operation transformation and convergence

Comprehensive guide to secure password handling, hashing, breach detection, and system design

Learn secure payment processing, PCI compliance, webhooks, and subscription data modeling with Stripe.

Real-time presence and awareness systems showing who is active and their live state

Design pattern enabling applications to communicate with multiple third-party services through a single, consistent interface

Use separate message queues per channel to avoid noisy neighbor problems and enable independent scaling.

Algorithms to fairly distribute API capacity and prevent system abuse

Control how often actions occur to protect systems from abuse and overload

Manage server state efficiently using React Query with caching, revalidation, and mutations

Scale database reads using replicas while routing all writes through a primary.

Techniques for smooth, real-time driver tracking on maps with GPS filtering and animation

Keep application data synchronized with live server changes using efficient patterns

In-memory data structure store enabling fast caching, rate limiting, and real-time operations

Master HTTP-based API design using REST principles, resource naming, status codes, and pagination.

Time-based job scheduling using cron with idempotency and distributed coordination

Design database schemas using tables, columns, data types, and constraints effectively

Server-pushed real-time data delivery using HTTP without polling or bidirectional protocols

Programmable network proxy enabling offline support, caching, and background sync for web apps

Master Amazon SQS for decoupled, scalable message processing architectures

Disciplined approach to modeling UI state using finite state machines

Design services without storing state between requests for infinite horizontal scaling

Master when to block for responses versus fire-and-forget in distributed systems.

Patterns and techniques to keep applications working when external APIs fail or degrade

Algorithm combining two document versions using a common ancestor to automatically resolve non-overlapping changes

Learn how columnar databases and time-series partitioning enable fast analytics on billions of rows

Choose between upgrading single machines or adding multiple machines to handle growth.

Backbone systems that convert raw video uploads into multi-resolution streams delivered globally.

Browser-based audio creation, processing, and control via JavaScript without plugins.

Browser-native cryptographic operations for encryption, decryption, and key management without external libraries

Move heavy computation off the main thread using Web Workers to keep UI responsive.

HTTP push notifications from external services to your server for event-driven workflows

Peer-to-peer audio, video, and data communication directly between browsers without plugins

Master WebSocket architecture for real-time two-way communication at scale

Compare polling, SSE, and WebSockets for real-time web communication

Master NoSQL database selection, document stores, key-value stores, and data modeling patterns.

Fixed number of long-running processes continuously dequeuing and processing tasks from a shared queue

Build real-time collaborative apps with Yjs: syncing, offline support, persistence, and presence awareness.

Lightweight React state management library with minimal boilerplate and selective re-renders