Software engineering concepts explained with Mermaid diagrams — updated daily. Inspired by ByteByteGo.
The CAP Theorem says distributed databases can only guarantee two of three properties: Consistency, Availability, and network Partition tolerance. It matters because it forces you to consciously trade off one property, ensuring your system design aligns with what your application actually needs.
Database replication is the process of copying data from one database (the primary) to one or more other databases (the replicas) in real time. This matters because replicas enable read scaling, geographic redundancy, and high availability—if the primary fails, a replica can be promoted to keep the system running.
A CDN caches your content on geographically distributed servers so when a user requests a file, their browser fetches it from the nearest edge location instead of your origin server. This reduces latency, decreases load on your origin, and improves resilience—requests served from a cache 100ms away load 10x faster than requests bouncing across continents to a single origin.
OAuth 2.0 is a delegated authorization protocol that lets users grant third-party applications access to their resources on another service without sharing passwords. It matters because it enables secure, user-controlled access delegation across services while maintaining strong security boundaries—eliminating the need to share credentials directly.
The CAP Theorem states that a distributed system can guarantee at most two of three properties: Consistency (all nodes see the same data), Availability (always responsive), and Partition tolerance (works despite network failures). It matters because every system design requires tradeoffs between these three, and knowing which to sacrifice guides architectural decisions for databases and services.
Database replication is the process of copying data from a primary database to one or more replica databases in real-time or near-real-time, keeping them synchronized. It enables high availability by providing failover when the primary fails, improves read performance by distributing queries across replicas, and protects against data loss.
A CDN caches your content on servers distributed globally, so when a user requests it, they get served from the nearest edge location instead of traveling all the way back to your origin server. This dramatically reduces latency and bandwidth costs while increasing availability, since even if your origin goes down, cached content keeps flowing.
OAuth 2.0 lets users authorize apps to access their data on another service by redirecting them to log in once, then issuing the app a token instead of storing passwords. This matters because it prevents apps from ever seeing passwords, limits what each app can access, and is how social login and third-party integrations securely work today.
The CAP Theorem states that distributed systems can guarantee at most two of three properties: Consistency (all nodes see identical data), Availability (always responds), and Partition tolerance (survives network splits). It matters because it forces architectural trade-offs—you must choose which property to sacrifice based on your application's needs.
Database replication is the process of copying data from a primary database to one or more secondary databases in real-time or near real-time. It matters because it enables high availability, fault tolerance, and read scalability—if the primary fails, you can fail over to a replica, and you can distribute read traffic across multiple copies.
A CDN directs user requests to the geographically nearest edge server, which serves cached content if available or fetches it from the origin to cache for future requests. This cuts latency by serving content nearby and distributes traffic load across many servers instead of overwhelming a single origin.
OAuth 2.0 is a protocol that lets users grant third-party apps access to their resources on another service without sharing passwords, using delegation via access tokens. It matters because it eliminates password sharing, reduces security surface area, and enables users to revoke access instantly without changing credentials.
The CAP Theorem says distributed systems can guarantee at most two of three properties: Consistency (all nodes see same data), Availability (responds to requests), and Partition tolerance (survives network failures). Understanding CAP forces you to design with explicit tradeoffs—you cannot have all three, so you must choose which two matter most for your application.
Database replication is the process of copying data from one database to one or more replica databases in real-time or near real-time, keeping them synchronized. It matters because it enables read scaling, high availability, and disaster recovery by distributing queries across multiple nodes and ensuring data survives node failures.
A CDN distributes your content across geographically dispersed servers so users download from a location physically close to them instead of always hitting your origin server. This dramatically reduces latency, decreases bandwidth costs, and improves availability since content is cached at multiple edge locations.
OAuth 2.0 is an authorization protocol that lets users grant third-party applications access to resources without sharing passwords — the app redirects to an identity provider, the user approves, and gets a token. It matters because it's the standard for secure API delegation, enabling microservices and federated auth while keeping secrets safe from clients.
The CAP Theorem states that a distributed system can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (remains operational), or Partition tolerance (survives network splits). Understanding CAP forces you to choose which two properties to optimize for when building databases or services, since you cannot achieve all three simultaneously.
Database replication copies data across multiple database instances so that changes to one database are automatically synchronized to replicas. It matters because it enables high availability by preventing single points of failure, distributes read load across replicas, and protects against data loss.
A CDN (Content Delivery Network) caches your content on geographically distributed servers worldwide so that users fetch files from the server closest to them instead of your origin server. This reduces latency, decreases bandwidth costs, and improves site performance and user experience across different regions.
OAuth 2.0 is a protocol that lets users authorize third-party applications to access their resources on another service without sharing their password directly, using tokens instead. It matters because it improves security by limiting app access, eliminates password sharing across services, and enables seamless platform integration.
The CAP Theorem states that any distributed database can guarantee at most two of three properties: consistency (all nodes see the same data), availability (the system always responds), and partition tolerance (it survives network splits). It matters because it forces you to make explicit tradeoffs when designing systems—you can't have all three, so you must consciously choose which two match your application's actual needs.
Database replication is the process of copying data from one database server to other servers in real time, keeping multiple synchronized copies across different machines. It matters because it improves availability through failover options when servers fail, distributes read traffic across replicas for better performance, and enables geographic data distribution for lower latency in different regions.
A CDN caches your content on geographically distributed servers worldwide, so when a user requests a file, they get it from the nearest edge server instead of your origin server. This dramatically reduces latency, cuts origin server load, and delivers content faster to users globally regardless of their location.
OAuth 2.0 is a standardized protocol that lets users grant third-party applications access to their resources on another service without sharing their password. It eliminates the need to share credentials across services, reduces security risks from password breaches, and enables seamless integrations like "Login with Google" or "Login with GitHub".
The CAP Theorem states that a distributed system can guarantee at most two of three properties: Consistency (all nodes see the same data), Availability (the system always responds), and Partition tolerance (nodes staying connected). This matters because it forces architects to consciously choose what to sacrifice—there's no perfect system, only informed tradeoffs.
Database replication is copying data from a primary database to one or more secondary replicas in real-time, keeping them synchronized. It enables high availability by allowing failover if the primary fails, improves read performance by distributing queries across replicas, and protects against data loss.
A CDN serves a request by routing it to the geographically nearest edge server, which caches and returns a copy of the requested content instead of making the user wait for a round trip to the origin server. This cuts latency from hundreds of milliseconds to tens, reduces bandwidth costs, and shields your origin server from traffic spikes.
OAuth 2.0 is an authorization protocol that allows users to grant third-party applications access to their resources on another service without sharing passwords, using tokens instead of credentials. It eliminates the need to trust third-party apps with passwords, enables fine-grained permission scoping, and is the industry standard for secure delegated access across APIs.
The CAP Theorem states that a distributed system can guarantee at most two of three properties: consistency (all nodes see the same data), availability (system responds to requests), and partition tolerance (system survives network splits). This matters because it forces you to consciously choose which trade-offs fit your application's needs rather than assuming you can have everything.
Database replication copies data across multiple database instances in real-time, keeping them synchronized. It matters because it enables high availability, fault tolerance, and load distribution—if one database fails, others continue serving requests.
A CDN (content delivery network) stores copies of your static content like images, videos, and CSS on geographically distributed servers, then serves each user from the location closest to them. This matters because it reduces latency, decreases load on your origin server, and provides better performance for global users.
OAuth 2.0 is an authorization protocol that lets users grant third-party apps access to their resources without sharing passwords. It matters because it's the industry standard for secure delegated access, enabling you to build integrations that users trust and reducing your app's liability for storing credentials.
The CAP Theorem states that a distributed system can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (system responds to requests), and Partition tolerance (system works despite network splits). Understanding this tradeoff is crucial because every distributed system design decision depends on which guarantee you prioritize based on your use case.
Database replication is the process of copying and synchronizing data from a primary database to secondary servers in real-time. It matters because it ensures high availability through failover, improves read performance by distributing queries to replicas, and provides disaster recovery by maintaining copies across different locations.
OAuth 2.0 is an authorization protocol that lets users grant third-party applications access to their resources without sharing passwords, by redirecting them to log in with their identity provider. It matters because it's the industry-standard way to securely delegate access, powering login flows on most platforms while keeping credentials safe and enabling revocable, scoped permissions.
CAP Theorem says a distributed system can guarantee at most two of three properties: Consistency (all nodes see the same data), Availability (the system responds to requests), and Partition tolerance (system works when networks split). It matters because it forces explicit tradeoffs—you can't have all three, so you must choose which two fit your use case.
Database replication is the process of copying data from one database instance to one or more other instances in real-time or near real-time. It matters because it enables high availability, fault tolerance, and geographic distribution—if one database fails, others contain the same data, and users in different regions can read from nearby copies.
A CDN caches your static assets on servers geographically close to users, so when someone requests a file, they fetch it from the nearest edge server instead of your origin. This dramatically cuts latency and bandwidth costs while scaling to millions of users without melting your main infrastructure.
The CAP Theorem says a distributed system can guarantee at most two of three properties: Consistency (all nodes see identical data), Availability (system responds to requests), and Partition tolerance (system survives network failures). This matters because it forces you to choose which two properties to prioritize when designing distributed systems based on your use case.
Database replication copies data across multiple database servers in real-time so every replica stays synchronized. This protects against failures, enables geographic distribution for faster access, and allows reads to be spread across replicas instead of hitting a single overloaded server.
A CDN is a network of geographically distributed servers that cache and serve content from locations close to users, routing requests based on geography to minimize distance. This dramatically reduces latency, saves bandwidth costs, and improves user experience especially for globally distributed audiences where serving from a single origin would be slow.
OAuth 2.0 is an authorization protocol that lets users grant third-party apps access to their resources on another service without sharing passwords. It matters because it enables secure, delegated access across services while keeping credentials private and letting users revoke access granularly.
The CAP Theorem says distributed systems can have at most two of three things: consistency (all nodes see the same data), availability (always responsive), and partition tolerance (survives network splits). It matters because it forces you to choose which tradeoff fits your use case instead of pretending you can have all three.
Database replication is copying data from one database to one or more other databases in real-time or near-real-time so they stay synchronized. This matters because it enables high availability (if one database fails others can serve traffic), geographic distribution (serve users from nearby servers), and read scaling (distribute queries across replicas).
A CDN (Content Delivery Network) serves requests by routing users to the geographically closest server that caches your content, reducing latency compared to always hitting your origin server. This matters because faster content delivery improves user experience, reduces bandwidth costs, and handles traffic spikes without overwhelming your infrastructure.
OAuth 2.0 is an authorization protocol that lets users grant third-party applications access to their resources on another service without sharing their password. It matters because it enables secure delegated access, reducing credential exposure and letting users revoke app permissions independently without changing their password.
The CAP Theorem states that a distributed system can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (the system remains responsive), and Partition tolerance (the system survives network splits). This matters because every distributed system design involves trade-offs—you must choose which two of the three to prioritize based on your application's needs.
Database replication is the process of copying data from a primary database to one or more secondary databases, keeping them synchronized in real-time or near-real-time. It matters because it enables high availability, distributes read load across multiple servers, provides disaster recovery by maintaining backups in different locations, and ensures data resilience if the primary fails.
A CDN (Content Delivery Network) caches your static content on geographically distributed servers worldwide, then routes user requests to the nearest edge server instead of your origin. This dramatically reduces latency, bandwidth costs, and origin server load by serving content locally to each user's region.
OAuth 2.0 is a protocol that allows users to grant third-party applications access to their resources without sharing passwords, using authorization tokens instead. It matters because it enables secure delegated access, reduces password exposure, and powers the "Sign in with Google/GitHub" patterns you see everywhere.
The CAP Theorem states that distributed systems can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (the system responds to requests), and Partition tolerance (the system survives network splits). Understanding CAP forces you to make deliberate tradeoffs when designing databases and services, helping you pick the right tool for your reliability and performance constraints.
Database replication is the process of copying and maintaining identical copies of a database across multiple servers or data centers. It matters because it improves system availability, allows distributing read queries across replicas for better performance, and protects against data loss if one database fails.
A CDN (Content Delivery Network) caches your content on geographically distributed servers, and when a user requests data, the CDN routes the request to the closest server instead of your origin, returning the cached copy. This matters because it drastically reduces latency for end users worldwide, decreases load on your origin servers, and improves overall application performance and reliability.
OAuth 2.0 is an authorization protocol that lets a user grant a third-party application access to their resources on another service without sharing their password, using delegated tokens instead. This eliminates the need to share credentials across services, reduces attack surface if an app is compromised, and enables seamless user experiences like "Sign in with Google."
The CAP Theorem states that a distributed system can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (the system stays responsive), and Partition tolerance (the system works despite network failures). Understanding CAP forces you to consciously choose which guarantee to sacrifice in your system design, influencing every architectural decision about databases and communication patterns.
Database replication is the process of copying and maintaining identical datasets across multiple database instances or servers. It matters because it enables high availability, fault tolerance, and load distribution—if one database fails, others can take over, and read operations can be spread across replicas to improve performance.
A CDN stores copies of your content on servers around the world, then serves each user from the server geographically closest to them instead of fetching from your origin server every time. This dramatically reduces latency and bandwidth costs because requests travel shorter distances, and even a 100ms difference in page load time significantly impacts user retention and SEO ranking.
OAuth 2.0 is an authorization protocol that lets users grant third-party apps access to their resources on another service without sharing passwords, using tokens that can be revoked or scoped to specific permissions. It matters because it's the standard powering single sign-on across the web, reduces credential exposure, and lets developers build integrations without handling sensitive passwords.
The CAP Theorem states that distributed systems can guarantee only two of three properties: consistency (uniform data across nodes), availability (system responsiveness), and partition tolerance (resilience to network splits). It matters because it reveals the fundamental trade-offs in distributed design—you must choose which two properties matter most for your use case rather than hoping for all three.
Database replication copies data from a primary database to one or more secondary databases in real time or near real time. It matters because it improves availability, enables read scaling, and provides disaster recovery so that if the primary fails, a replica can take over.
A CDN caches your content on geographically distributed servers, routing each user's request to the nearest edge location instead of your origin server. This dramatically reduces latency for end-users, decreases origin server load, and improves availability by serving cached content even if your origin is down.
OAuth 2.0 is an authorization protocol that lets users grant third-party applications access to their data without sharing passwords by delegating to a trusted identity provider. It matters because it powers secure single-sign-on integrations across the web while limiting the blast radius if a user's credentials are compromised.
The CAP Theorem states that distributed systems can guarantee at most two of three properties: Consistency (all nodes see the same data), Availability (system always responds), and Partition tolerance (survives network splits). You need to understand this because every distributed system you design requires trading off one property, and the choice defines how your system behaves under failure.
Database replication is the process of copying and maintaining identical copies of data across multiple database servers in real time. It matters because it enables high availability, improves read performance by distributing queries, and provides disaster recovery so that if one database fails, others can take over without losing data.
A CDN (Content Delivery Network) caches your content on servers distributed globally, routing user requests to the nearest edge location instead of your origin server. This dramatically reduces latency and bandwidth costs while improving reliability, which is why CDNs are essential for serving static assets, video, and APIs at scale.
The CAP Theorem states that distributed systems can guarantee at most two of three properties: consistency (all nodes see the same data), availability (system stays responsive), and partition tolerance (system survives network splits). It matters because you must make tradeoffs when designing systems—you can't have all three, so you choose which guarantees matter most for your use case.
Database replication is the process of copying data from one database (primary) to one or more other databases (replicas) in real-time or near real-time. It matters because it enables high availability, improves read scalability by distributing queries across replicas, and provides disaster recovery by maintaining backup copies in case the primary fails.
A CDN (Content Delivery Network) stores copies of your content on servers distributed globally, then serves each user from the geographically nearest location instead of your origin server. This reduces latency, decreases bandwidth costs, and prevents your origin server from being overwhelmed—critical for scaling applications to millions of users across different regions.
OAuth 2.0 is an authorization protocol that lets users grant third-party apps access to their resources without sharing passwords — the user authenticates with the original service, which then issues a token the app can use. It matters because it's the industry standard for secure delegation: it eliminates password sharing, limits what each app can access, and makes revocation instant.
The CAP Theorem states that distributed systems can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (system remains operational), and Partition tolerance (survives network failures). Understanding CAP helps you make intentional tradeoffs when designing systems—you cannot have all three, so you must choose which two matter most for your use case.
Database replication copies data from a primary database to replicas in real-time, keeping multiple copies synchronized across different servers or regions. It matters because it increases availability through redundancy, scales read performance by distributing queries across replicas, and enables automatic failover if the primary database fails.
A CDN (Content Delivery Network) serves requests by caching and distributing content across geographically distributed servers, routing users to the nearest location instead of always hitting the origin server. This dramatically reduces latency, decreases origin server load, and improves availability for global users.
OAuth 2.0 lets users authorize third-party apps to access their data without sharing passwords—the user logs into the original service, grants permission, and the app gets a token to make requests on their behalf. It matters because it prevents users from sharing credentials, reduces security risks, and lets services revoke access independently.
The CAP Theorem states that a distributed system can guarantee at most two of three properties: consistency (all nodes see the same data), availability (system responds to requests), and partition tolerance (system survives network splits). This tradeoff helps you choose the right database and architecture for your application rather than assuming you can have all three.
Database replication is the process of copying data from one database to one or more other databases in real-time or near-real-time, keeping multiple copies synchronized. It enables high availability by allowing queries to be distributed across replicas, prevents data loss if a primary server fails, and improves read performance by spreading traffic across multiple copies.
A CDN copies your content across geographically distributed servers, so when a user requests a file, they get it from the server nearest to them instead of your origin. This dramatically reduces latency and bandwidth costs while improving availability since requests don't all bottleneck through a single datacenter.
OAuth 2.0 is a standardized protocol that lets users grant third-party applications access to their resources on another service without sharing their password directly. It matters because it's the foundation of single sign-on, federated identity, and secure API access — reducing security risks while improving user convenience across modern web platforms.
The CAP Theorem states that a distributed database can only guarantee two of three properties: consistency (all nodes see the same data), availability (system responds), and partition tolerance (survives network splits). This matters because every database prioritizes two of these three, and that choice directly shapes how you design your application's data layer.
Database replication is the process of copying data from one database to one or more other databases in real-time or near-real-time, keeping them synchronized. It matters because it improves reliability by preventing single points of failure, enables better performance through read scaling, and ensures your system can survive hardware failures or data center outages.
A CDN (Content Delivery Network) serves a request by routing it to the nearest geographically distributed server that caches your content, rather than always hitting your origin server. This matters because it dramatically reduces latency for users worldwide, decreases origin server load, and improves overall application performance.
OAuth 2.0 is an authorization protocol that lets users grant applications access to their resources on another service without sharing passwords. It matters because it decouples authentication from credential exposure, enables granular permission control, and provides the standardized foundation for secure third-party integrations.
The CAP Theorem states that a distributed system can guarantee only two of three properties: consistency (all nodes see the same data), availability (the system always responds), and partition tolerance (the system survives network failures). Understanding CAP forces you to make explicit tradeoffs when designing databases and services—choosing which property to sacrifice when network problems inevitably occur.
Database replication is the process of copying data from a primary database to one or more replica databases, keeping them synchronized in real time. It matters because it improves availability, fault tolerance, and read performance by distributing the data across multiple servers.
A CDN (Content Delivery Network) caches copies of your content on geographically distributed servers, so users download from a location near them instead of your origin server. This dramatically reduces latency, cuts bandwidth costs, and improves resilience by spreading traffic load across multiple nodes.
OAuth 2.0 is an open standard that lets users authorize third-party applications to access their data on another service without sharing their password. It matters because it eliminates the need for users to trust every app with their credentials, reducing attack surface and enabling secure delegated access across services.
The CAP Theorem says a distributed system can guarantee only two of three properties: Consistency (all nodes see the same data), Availability (always responsive), or Partition tolerance (works despite network failures). Understanding CAP matters because it forces explicit tradeoffs when designing databases—you must choose which two properties matter most for your application, since no system can have all three.
Database replication is the process of copying data from one database server to one or more other servers in real time, keeping them synchronized. It matters because it enables high availability, fault tolerance, load distribution, and geographic redundancy so your system can survive failures and serve users faster across regions.
A CDN stores copies of your content on servers worldwide, then serves each user from the geographically closest server instead of your origin. This dramatically reduces latency and bandwidth costs, ensuring fast page loads for users regardless of their location.
OAuth 2.0 is a delegated authorization protocol that lets users grant third-party apps access to their resources on another service without sharing passwords. It eliminates password sharing, reduces your app's liability for storing credentials, and lets users revoke access per-app instead of changing their password.
The CAP Theorem states that distributed systems can guarantee only two of three properties: consistency (all nodes have identical data), availability (the system stays online), and partition tolerance (survives network failures). Understanding CAP matters because it forces you to consciously choose which two properties to optimize for, directly shaping design decisions for databases, caching, and replication strategies.
Database replication copies data from one database server (primary) to one or more other servers (replicas) in real-time, keeping them synchronized. This matters because replicas enable read scaling, high availability through failover, and geographic distribution to reduce latency for users worldwide.
A CDN is a geographically distributed network of servers that cache and serve your content from locations closest to each user, cutting down latency instead of always fetching from your origin server. This matters because faster load times improve user experience and conversion rates, reduce your bandwidth costs, and provide built-in redundancy and DDoS protection.
OAuth 2.0 is an authorization protocol that allows users to grant third-party applications access to their resources on another service without sharing their password. This matters because it enables secure delegation of permissions, reduces password sharing across sites, and forms the foundation for modern single sign-on and API access patterns.
gRPC uses Protocol Buffers and HTTP/2 for high-speed binary communication between services, while REST uses JSON over HTTP/1.1 for human-readable text-based APIs. gRPC is faster and more efficient for service-to-service communication, but REST is simpler to debug and better for public APIs; choose gRPC for performance-critical internal systems and REST for broad compatibility.
A URL shortener maps long URLs to concise identifiers by storing the mapping in a database and serving redirects via a lightweight service. It demonstrates key system design concepts like database indexing, horizontal scaling, caching strategies, and handling millions of redirects with minimal latency.
Docker containers bundle your application code, runtime, and dependencies into an isolated, lightweight virtual environment that runs consistently across any machine. This matters because it eliminates "works on my machine" problems, enables reproducible deployments, and simplifies scaling—you package once and run everywhere.
Pub/Sub broadcasts a single message to multiple subscribers simultaneously, while a message queue stores messages for one consumer to retrieve and process. Use pub/sub to notify many services of an event, and queues when you need durable, load-balanced processing of individual messages.
React renders components by converting JSX into a virtual representation, compares it to the previous state to find differences, then updates only the changed DOM elements. Understanding this reconciliation process helps you write performant components, avoid unnecessary re-renders, and make informed decisions about component architecture and state management.
HTTP/2 is a newer protocol that multiplexes multiple requests over a single TCP connection with binary framing, while HTTP/1.1 sends requests sequentially or through separate connections, causing head-of-line blocking. This reduces latency and improves bandwidth utilization, making web applications significantly faster without requiring developers to change how they write code.
A saga is a sequence of local transactions across multiple services where each step publishes an event triggering the next, with rollback transactions to undo failures. It matters because you can't use traditional database transactions across separate services, so sagas maintain consistency when an operation spans multiple databases or microservices.
A service mesh is an infrastructure layer managing service-to-service communication in microservices, with Istio using sidecar proxies to intercept and control network traffic. It abstracts distributed systems concerns like load balancing and security from application code, letting you enforce policies consistently across all services without changes.
The Circuit Breaker Pattern is a mechanism that prevents a service from repeatedly calling a failing external dependency by monitoring failures and temporarily stopping requests when a threshold is reached. It matters because it prevents cascading failures, gives the failing service time to recover, and avoids wasting resources on calls that will inevitably fail.
A compiler transforms human-readable source code into machine-executable instructions by parsing syntax, analyzing semantics, and generating optimized binary output. Understanding compilers matters because it reveals how languages enforce correctness, how optimizations impact runtime performance, and how to write better code that cooperates with the compiler's optimization passes.
A search engine index is a massive inverted data structure that maps words and phrases to the documents containing them, built by crawlers that fetch pages, extract content, and store searchable metadata in a distributed database. Knowing how indexing works teaches you about crawlers, distributed systems, data structures, caching, and ranking—core patterns you'll apply to your own search features and databases.
Git uses content-addressable storage where files and commits are identified by SHA-1 hashes of their contents, stored as immutable objects in a directed acyclic graph. Understanding this model helps developers predict how branching, merging, and recovery work without fear of losing committed work.
ACID transactions are database operations that guarantee Atomicity (all-or-nothing), Consistency (valid state), Isolation (concurrent operations don't interfere), and Durability (committed data persists). They matter because they prevent data corruption, race conditions, and partial failures that would otherwise leave your database in an inconsistent state when failures occur.
Event-Driven Architecture is a design pattern where independent services communicate by emitting and reacting to events asynchronously rather than calling each other directly. This decoupling lets components scale independently, respond dynamically to state changes, and be modified without breaking dependent services.
WebSockets are a network protocol that establishes a persistent, bidirectional connection between a client and server, allowing both sides to send messages independently without the request-response overhead of HTTP. This makes them essential for real-time features like live notifications, collaborative editing, or multiplayer interactions where low latency and frequent updates are critical.
Rate limiting algorithms control how many requests a client can make within a time window by tracking requests and rejecting excess ones. This protects services from abuse, prevents resource exhaustion, and ensures fair access for all users.
Consistent hashing maps keys to nodes in a distributed system so that adding or removing nodes only remaps a small fraction of keys, not all of them. This is crucial because it minimizes cache misses and rebalancing overhead when scaling clusters, making systems like Redis, Memcached, and CDNs efficient.
A database index is a data structure that maintains a sorted copy of selected columns, allowing the database to find rows without scanning every table entry. It matters because it dramatically speeds up queries and filters, reducing latency from seconds to milliseconds while increasing throughput for production applications.
Kubernetes scheduling is the process where the control plane assigns pods to nodes based on resource requests, affinity rules, and node availability. Understanding how this works matters because it directly impacts your application's resilience, resource efficiency, and ability to handle scale without manual intervention.
A monolith is a single unified codebase handling all features, while microservices split functionality into independent, deployable services. Monoliths are simpler to start but harder to scale; microservices allow independent scaling and updates but introduce complexity in coordination and debugging.
A message queue is a system where producers send messages to a buffer and consumers retrieve and process them asynchronously, decoupling the sender from the receiver. It enables scalability and reliability by allowing services to operate at different speeds and handle failures without blocking each other.
An API Gateway is a server that sits between clients and backend services, routing requests to the appropriate service while handling authentication, rate limiting, and request transformation. It matters because it centralizes cross-cutting concerns, abstracts service complexity from clients, and lets you scale backend services without changing client code.
Redis is an in-memory data store that acts as a fast cache layer between your application and database, storing frequently accessed data in RAM for instant retrieval. It matters because caching with Redis dramatically reduces database load and response times, enabling your system to handle more concurrent users without scaling the database itself.
JWT (JSON Web Token) is a stateless authentication mechanism where the server signs a token containing user claims, and the client sends it with each request without server-side session storage. It matters because it enables scalable, distributed systems where any server can validate tokens independently, critical for microservices and mobile backends.
The CAP Theorem states that a distributed system can only guarantee two of three properties: Consistency (all nodes see same data), Availability (responsiveness), and Partition tolerance (surviving network failures). Understanding CAP helps you make trade-off decisions when designing databases and services—you must accept that perfect consistency and availability cannot coexist during network outages.
Database replication is the process of copying and synchronizing data across multiple database instances, either synchronously or asynchronously. It matters because it enables high availability, fault tolerance, and geographic redundancy—so if one database fails, others continue serving requests and your system stays online.
A CDN caches your content on geographically distributed servers worldwide, so when a user requests a file, the closest server delivers it instead of the origin. This reduces latency for users globally and decreases load on your origin server, making your application faster and more scalable.
OAuth 2.0 is an authorization protocol that lets users grant third-party applications access to their resources on another service without sharing passwords directly. It matters because it decouples authentication from authorization, limits credential exposure, and enables seamless single-sign-on while reducing the blast radius if any application is compromised.
Sharding splits a single large database into smaller pieces (shards) spread across multiple servers. A shard router uses a key (e.g. user_id) to decide which shard holds the data. Reads and writes go only to the relevant shard — no full-table scans across all data.
A load balancer sits in front of your servers and distributes incoming requests so no single server gets overwhelmed. Round-robin sends requests in turn; least-connections routes to whichever server is least busy.
DNS turns human-readable names into IP addresses. The recursive resolver does the legwork — it asks the root, then the TLD (.com), then the authoritative nameserver, then caches the answer.
TLS negotiates a symmetric session key using asymmetric cryptography. The certificate proves the server's identity; the handshake produces a shared secret that neither side transmits directly.
When you type a URL, four parties cooperate to deliver the page in milliseconds. The DNS resolver does the work most people forget.
A language model never "writes" — it predicts the next token, one at a time, sampling from a probability distribution.
Modern software is a loop, not a line. The faster the loop runs, the smaller and safer each change is.
A typical 2026 fullstack request: cached at the edge, rendered close to the user, and only hits the database when nothing else can answer.