Concepts
Mental models and definitions that make the code understandable.
896 published
Page 8 of 9
Deployment Slots: Staging Environments Inside One Service
Deployment slots give a running service parallel, addressable copies that can be warmed and swapped, reducing release risk without a second cluster.
Envelope Encryption
Envelope encryption protects data with a per-object data key and wraps that key with a long-lived master key held in a KMS or HSM, limiting exposure and simplifying rotation.
Error Taxonomy
An error taxonomy classifies failures by cause, retryability, and ownership, so clients, operators, and dashboards respond consistently instead of guessing.
Exactly-Once Semantics
Exactly-once semantics means each event affects the final result once, even after retries or failures; it requires idempotent or transactional end-to-end handling.
Exploratory Testing
Exploratory testing combines learning, test design, and execution in real time, using charters and time boxes to probe where scripted tests cannot anticipate.
Failover
Failover shifts traffic or workload to a standby when the primary fails, and its reliability depends on detection, state, and regular rehearsal.
Failure Domain
A failure domain is the boundary within which a fault is contained, such as a process, rack, zone, or region, and it determines what fails together.
Fault Injection
Fault injection deliberately introduces latency, errors, or resource failures to verify that a system detects, contains, and recovers from them.
Feature Flags vs Configuration: Different Lifetimes, Different Risks
Flags control code paths and are meant to be removed; configuration tunes behaviour and persists. Mixing them creates permanent toggles nobody dares delete.
Fitness Functions: Automated Checks on Architecture Quality
A fitness function is an automated test of an architectural property, turning vague goals like loose coupling into checks that fail the build.
Flaky Tests
A flaky test passes and fails on the same code, eroding trust in the suite; the fix is finding the nondeterminism, not rerunning until green.
Golden Paths: The Supported Way to Build and Ship
A golden path is a curated, supported route through the platform that makes the secure and observable option the easiest option for product teams.
Gossip Protocols
Gossip protocols spread membership and state information peer to peer through periodic random exchanges, converging without a central coordinator.
Graceful Degradation
Graceful degradation preserves core functionality by shedding optional features when capacity or dependencies fail, keeping the service useful under stress.
Health Checks: Signals That Actually Reflect Service Health
Health checks decide whether traffic reaches an instance; shallow checks miss broken dependencies, while deep checks amplify outages across the fleet.
Hinted Handoff
Hinted handoff lets a replica accept a write for an unavailable peer, store a hint, and replay it when that peer recovers, improving availability during partitions.
Incident Learning
Incident learning turns outages into durable improvements by examining contributing factors, verifying follow-through, and sharing lessons beyond the responders.
Integration Testing
Integration testing exercises real components together, including databases, queues, and HTTP boundaries, to verify the wiring that unit tests deliberately fake.
Internal Developer Platform: A Product, Not a Tool Dump
An internal developer platform bundles self-service infrastructure, delivery, and observability behind one interface, treating developers as its customers.
Key Management
Key management covers the full lifecycle of cryptographic keys: generation, storage, distribution, use, rotation, and destruction, with policy and audit at every step.
Lakehouse
A lakehouse adds warehouse-style tables, transactions, and governance on top of cheap object storage, so one copy serves BI, streaming, and machine learning.
Late Data
Late data is an event that arrives after its event-time window was expected to close. Handling it requires allowed lateness, retractions, or reprocessing.
Load Balancing Algorithms and When Each One Fails
Round robin, least connections, and consistent hashing spread traffic differently; the wrong algorithm creates hotspots that look like capacity problems.
Lost Updates
A lost update happens when two transactions read the same value and both write it back, so one change silently overwrites the other.
Master Data
Master data is the shared, slowly changing core entities such as customers, products, and suppliers that multiple systems must agree on.
Migration Waves: Sequencing Work You Cannot Do at Once
Migration waves group systems into ordered batches by dependency and risk, turning an impossible big-bang move into a series of reversible steps.
Mutual TLS (mTLS)
Mutual TLS authenticates both ends of a connection with certificates, giving services a cryptographic identity that works without shared secrets or user context.
Normalization vs Denormalization
Normalization removes duplicate facts to protect integrity; denormalization duplicates selected facts to speed reads. The right balance depends on write rules and query shape.
OAuth PKCE Pitfalls
PKCE stops authorization-code interception, but weak verifier handling, plain challenges, and missing state checks can quietly reopen the attack it was meant to close.
Observability-Driven Testing
Observability-driven testing uses traces, metrics, and logs as test evidence, asserting on system behavior rather than only on returned values.
Ownership Metadata: Making the Right Team Findable
Ownership metadata links a service to the team accountable for it, so alerts, reviews, and incidents route to people instead of a shared inbox.
Phantom Reads
A phantom read occurs when a transaction repeats a query and sees new rows inserted by another transaction, breaking a predicate-based decision.
Platform Scorecards: Measuring Service Health, Not Team Blame
Scorecards aggregate ownership, reliability, and security signals into a per-service view that guides improvement instead of ranking people.
Policy as Code: Guardrails You Can Test and Version
Policy as code expresses security and compliance rules as versioned, testable artifacts that gate pipelines and reconcile live systems instead of living in a wiki.
Query Planning
Query planning translates SQL into an execution plan by choosing access paths, join orders, and algorithms using statistics and cost estimates.
API Rate-Limit Headers
Rate-limit headers tell clients how much quota remains and when it resets, so they can back off before receiving a 429 instead of retrying blindly.
Readiness vs Liveness: Two Probes, Two Different Decisions
Readiness decides whether an instance receives traffic; liveness decides whether it should be restarted. Conflating them causes outages that are hard to diagnose.
Real-User Monitoring
Real-user monitoring collects performance and error data from actual sessions, revealing the long tail of devices, networks, and geographies that labs miss.
Redundancy
Redundancy duplicates components or capacity so the system survives failure, but it only helps when copies fail independently and failover works.
Regression Suite
A regression suite is the set of tests rerun after changes to prove existing behavior still works, curated and maintained to stay fast and trustworthy.
Release Train: A Predictable Cadence for Many Teams
A release train ships on a fixed schedule regardless of individual feature readiness, trading flexibility for coordination and predictability.
Reliability Target
A reliability target is the availability, latency, or durability a service promises over a window, chosen from user needs and cost rather than aspiration.
Request Signing
Request signing attaches a cryptographic signature to each HTTP request, proving the caller's identity and binding the signature to the method, path, headers, and body.
Resilience Budget
A resilience budget reserves capacity, error tolerance, and engineering time in advance so failures can be absorbed without breaching user-facing targets.
Risk-Based Testing
Risk-based testing allocates effort according to the likelihood and impact of failure, so the highest-risk areas receive the deepest verification first.
Row-Level Security
Row-level security pushes tenant and ownership filters into the database, so every query is constrained even when application code forgets a WHERE clause.
Software Bill of Materials (SBOM)
An SBOM is a machine-readable inventory of every component in a build, with versions, identifiers, and relationships, so teams can answer what is inside shipped software.
Schema-on-Read
Schema-on-read applies structure when data is queried rather than when it is written, trading upfront validation for flexibility and deferred errors.
Secret Rotation
Secret rotation replaces credentials on a schedule or after compromise, using overlapping validity windows so consumers switch without downtime.
Secure Defaults
Secure defaults make the safe configuration the automatic one, so users who never touch a setting still get encryption, least privilege, and closed access.
Service Catalog: The Map Your Organization Actually Needs
A service catalog records ownership, dependencies, and interfaces for every service, making it possible to answer who owns what and what breaks if it fails.
Service Discovery: Finding Instances Without Hardcoded Hosts
Service discovery maps logical service names to live instance addresses so clients and load balancers follow scaling, deploys, and failures automatically.
SLSA (Supply-chain Levels for Software Artifacts)
SLSA is a framework of build and source integrity levels, backed by signed provenance, that makes tampering with a software artifact detectable.
Smoke Tests
Smoke tests are a fast, shallow set of checks confirming a build or deployment is basically usable before deeper testing or real traffic begins.
Soak Tests
Soak tests hold a realistic load for hours or days to expose memory leaks, resource exhaustion, and gradual degradation that short runs miss.
Spike Tests
Spike tests apply a sudden surge of traffic to verify autoscaling, queues, and recovery cope with sharp load changes rather than steady growth.
Star Schema
A star schema places a central fact table of measurable events next to denormalized dimension tables, enabling simple joins and fast analytical aggregation.
Strangler Metrics: Proving the Old Path Is Really Dying
A strangler migration needs evidence, not optimism. Track traffic shifted, features live on the new path, and the blockers that keep the legacy system alive.
Surrogate Keys
Surrogate keys are cache tags attached to responses so a CDN can purge every object related to an entity in one call instead of enumerating thousands of URLs.
Synthetic Monitoring
Synthetic monitoring runs scripted probes from controlled locations, detecting availability, latency, and TLS or DNS failures before users report them.
Technical Debt: A Loan With Interest and a Repayment Plan
Technical debt is the future cost of a shortcut. Naming it, pricing it, and scheduling repayment keeps it a tool rather than a slow failure.
Tenant Isolation
Tenant isolation keeps one customer's data and workload from being observed, modified, or slowed by another, across storage, compute, caches, and background jobs.
Test Doubles
Test doubles replace real collaborators with dummies, stubs, spies, mocks, or fakes so a unit can be tested without slow or unpredictable dependencies.
Test Oracle
A test oracle is the source of truth that decides whether an observed result is correct, turning an executed check into a pass or fail judgment.
Token Introspection
Token introspection lets a resource server ask the authorization server whether an opaque token is active and what it grants, centralizing revocation and policy.
Token Revocation
Token revocation invalidates a grant before it expires, cutting off compromised sessions and ensuring logout actually ends access across clients and services.
Typosquatting
Typosquatting registers package or domain names that look like popular ones, tricking developers into installing malware through a single mistyped character.
Version Skew: Running Mixed Versions Without Breaking
Version skew is the normal state during rollouts: old and new code run side by side. Designing for it prevents silent incompatibilities and failed rollbacks.
Vulnerability Disclosure
Vulnerability disclosure is the coordinated process of receiving, triaging, fixing, and publishing security reports so defenders learn before attackers exploit them.
Watermarks
A watermark is a stream processor's estimate that no events earlier than a timestamp will arrive, letting it close windows and emit results with bounded delay.
Write Skew
Write skew is an anomaly where two concurrent transactions read overlapping data, write disjoint rows, and together violate an invariant that neither saw break.
API Gateway
An API gateway is the shared entry point for north-south traffic, handling routing, authentication, rate limits, and response aggregation before requests reach services.
API Versioning
API versioning lets clients and servers evolve independently by exposing explicit contract versions, so breaking changes ship without silently breaking existing callers.
Audit Logging
Audit logging records who did what, when, and from where for security-sensitive actions, supporting investigation and accountability rather than debugging.
Backup and Restore
Backups copy data so it can be recovered after deletion, corruption, or disaster. A backup is only as good as the last successful restore test.
Backward Compatibility
Backward compatibility lets new code read old data and new clients work with older servers, enabling independent deployment and safe rollback.
Blue-Green Deployment
Blue-green deployment runs two identical production environments and switches traffic from the live stack to a prepared one, making releases atomic and rollback fast.
Build Cache
A build cache stores outputs keyed by inputs so repeated builds reuse compiled artifacts, downloaded dependencies, and layers, cutting CI time without changing results.
Cache-Aside
Cache-aside loads data into the cache on demand, keeps the database authoritative, and requires explicit invalidation and stampede protection.
Cache Stampede
A cache stampede happens when a hot key expires and many concurrent requests miss it at once, sending a burst of identical load to the origin.
Content Delivery Network
A CDN caches content at edge locations close to users. It cuts latency and origin load, but introduces cache keys, invalidation, and consistency decisions.
Change Data Capture
Change data capture streams committed database changes as events, letting downstream systems react without dual writes or polling every table.
Chaos Engineering
Chaos engineering runs controlled failure experiments in production-like systems to validate resilience assumptions before real outages expose them.
CI/CD
CI/CD automates building, testing, and delivering software on every change, replacing manual release steps with a repeatable pipeline that keeps the main branch releasable.
Code Review
Code review is a structured inspection of a proposed change by peers, catching defects, spreading knowledge, and enforcing conventions before code reaches the mainline.
Connection Pooling
Connection pooling reuses a bounded set of database or upstream connections, avoiding per-request handshakes while keeping concurrency within the dependency's limit.
Consistent Hashing
Consistent hashing maps keys to nodes on a ring so adding or removing a node moves only a small fraction of keys instead of reshuffling the whole dataset.
Content Negotiation
Content negotiation lets clients request a representation by media type, language, or encoding through Accept headers, and the server selects and labels the response.
Contract Testing
Contract testing verifies that a consumer and provider agree on request and response shapes, catching integration breakage without running a full end-to-end environment.
CORS
CORS is a browser-enforced mechanism that lets a server declare which origins may read its responses. It relaxes the same-origin policy without weakening server security.
CQRS
Command Query Responsibility Segregation separates write models optimized for decisions from read models optimized for queries, at the cost of consistency and plumbing.
Content Security Policy
Content Security Policy is an HTTP response header that restricts which scripts, styles, frames, and connections a page may load, reducing the impact of cross-site scripting.
Dark Launch
A dark launch deploys and exercises new code in production without exposing its output to users, validating behavior on real traffic before a visible release.
Data Residency
Data residency constrains where data is stored and processed, requiring region-pinned storage, replication controls, and evidence that no copy leaves the allowed geography.
Data Retention
Data retention defines how long each class of data is kept and how it is destroyed. Clear schedules reduce storage cost, legal exposure, and privacy risk.
Database Index
A database index is an auxiliary structure that lets the engine find rows without scanning the whole table. It trades write cost and storage for faster reads.
Dead-Letter Queue
A dead-letter queue isolates messages that repeatedly fail processing, preserving them for diagnosis while the main queue continues to make progress.
Defense in Depth
Defense in depth layers independent preventive, detective, and responsive controls so one failure does not become a breach or outage.
Dependency Pinning
Dependency pinning fixes exact versions and integrity hashes for every dependency, so installs are reproducible and an upstream release cannot silently change your build.
Disaster Recovery
Disaster recovery restores service after a large-scale failure. It is measured by tested recovery time and data loss, not by the thickness of a plan document.