← Back to Software Engineering

Software Engineering Glossary

Key terms from the Software Engineering course, linked to the lesson that introduces each one.

736 terms.

A

Abbreviated approval chains
A designated "break glass" authority (often a senior engineer or on-call lead) can greenlight the release without full stakeholder sign-off
Lesson 1549 — Emergency Release Procedures
Abstract Factory
An Abstract Factory is like ordering a complete dining set.
Lesson 238 — Abstract Factory vs Factory Method
Accept when
The reviewer raises valid concerns about bugs, readability, maintainability, or team standards you missed.
Lesson 1619 — Receiving Code Review Feedback
Acceptance Criteria
Acceptance Criteria are specific to one user story.
Lesson 149 — Acceptance Criteria vs Definition of Done
Accepted
The team has agreed and implementation is underway or complete
Lesson 1703 — ADR Status and Lifecycle
Access control
Access control means restricting secret access to only those who need it—the principle of least privilege.
Lesson 746 — Access Control and Audit Logging for Secrets
Access control changes
A user requests elevated permissions, but only an administrator can grant them
Lesson 1037 — Separation of Duties
Access tokens
Access tokens are short-lived credentials that grant access to protected resources—think of them as temporary visitor badges.
Lesson 1021 — Access Tokens, Refresh Tokens, and Token Lifetime
Accessibility
Accessibility is ensuring people with disabilities can use your system equally well.
Lesson 1245 — Usability and Accessibility
Action
A log message or expression to evaluate
Lesson 1730 — Conditional Breakpoints and Breakpoint Actions
Adapter
Adapter is like buying a power plug adapter when traveling abroad—your device already exists, the outlet already exists, and they don't match.
Lesson 262 — Adapter vs Bridge: Understanding the DistinctionLesson 1264 — The Ports and Adapters Pattern
Adapters
Adapters are like specialized bridges or mechanisms that connect those ports to the outside world.
Lesson 1264 — The Ports and Adapters Pattern
Added complexity
More code means more to test, debug, and maintain
Lesson 170 — You Aren't Gonna Need It (YAGNI)
Adding new states
Adding new states is likely (system will evolve)
Lesson 311 — State Pattern vs Conditional Logic
Adding required parameters
requests missing the new mandatory field are rejected
Lesson 847 — Breaking vs Non-Breaking Changes
Additional Method Calls
A Decorator wraps another object, forwarding each method call. That's an extra function call on the stack for every operation. A chain of three decorators means three extra calls.
Lesson 282 — Performance Overhead of Structural Patterns
Additive changes
Adding optional fields is safe—old consumers ignore them
Lesson 1343 — Event Schemas and Contracts
Affected Scope
Include labels or tags showing which instances, regions, or customers are impacted.
Lesson 1160 — Alert Context: Including Diagnostic Information
aggregate
An aggregate is a cluster of related domain objects (entities and value objects) treated as a single unit for data changes.
Lesson 1284 — Aggregates and Consistency Boundaries
Aggregations happen frequently
Storing pre-calculated totals (like order_total alongside order items) avoids re-summing every time
Lesson 865 — Strategic Denormalization
Amplification
Amplification means repeating or crediting ideas from underrepresented colleagues when they're overlooked.
Lesson 1854 — Allyship and Advocacy in Engineering
Analogy
Imagine a coffee shop queue. In a push system, the barista is handed five orders at once (overwhelming). In a pull system, they take the next order slip only when they finish the current drink—smooth, sustainable flow.
Lesson 414 — Moving Tests Down the PyramidLesson 1339 — Events vs Messages vs CommandsLesson 1596 — Pull Systems vs Push Systems
Annotated tags
Annotated tags are full Git objects that store the tagger's name, email, date, and a message.
Lesson 1556 — Version Tagging in Git
Annotations
Annotations are also key-value pairs, but they're for storing non-identifying metadata that you don't query on.
Lesson 1445 — Labels, Selectors, and Annotations
Another example
The Classpath Exception in OpenJDK allows linking GPL Java libraries into non-GPL applications, solving a major compatibility problem.
Lesson 1876 — Dual Licensing and License Exceptions
API Gateway
An API Gateway is a server that acts as a single entry point for all external clients (web apps, mobile apps, third-party systems) into your microservices ecosystem.
Lesson 1327 — API Gateway Pattern
API Server
The central hub. Every request (deploy a container, scale up, check status) goes through the API server. It's the only component that talks directly to the datastore (etcd).
Lesson 1443 — Kubernetes Architecture Overview
Application servers
Application servers are immutable containers or instances that hold no local state
Lesson 1477 — Handling State in Immutable Systems
Architecture
Architecture consists of decisions that are:
Lesson 1223 — Architecture vs. Design
Architecture alignment
Architecture alignment means translating these goals into technical decisions that make them achievable.
Lesson 1233 — Business Goals and Architecture Alignment
Architecture governance
Architecture governance is the framework of processes, policies, and practices that ensure technical decisions align with organizational goals and standards.
Lesson 1251 — Architecture Governance and Standards
Arrange
Set up everything your test needs—create objects, configure dependencies, prepare test data. This is your setup phase.
Lesson 446 — Arrange-Act-Assert Pattern
Artifacts
Artifacts are immutable build outputs (compiled binaries, container images, packages) that flow through the pipeline.
Lesson 700 — Anatomy of a Deployment Pipeline
Assumptions
Clarifying constraints ("Assumes input array is pre-sorted")
Lesson 132 — Constraints and AssumptionsLesson 1684 — Code Comments and Inline Documentation
Asynchronous processing
Asynchronous processing means separating the acceptance of work from its execution.
Lesson 1385 — Asynchronous Processing and Message Queues
Asynchronous replication
The leader acknowledges writes immediately without waiting for followers. Faster, but followers may temporarily lag behind—creating the risk of reading stale data or losing recent writes if the leader fails.
Lesson 1402 — Leader-Follower Replication
At-Least-Once
The event is delivered one or more times. It will definitely arrive, but you might receive duplicates due to retries after network failures or timeouts. This is the most common practical guarantee.
Lesson 1344 — At-Least-Once vs Exactly-Once DeliveryLesson 1361 — Delivery Guarantees: At-Most, At-Least, Exactly-Once
At-Most-Once
The event is delivered zero or one time. It might get lost, but never duplicated. Think of throwing a letter into a mailbox and hoping it arrives—no tracking, no retries.
Lesson 1344 — At-Least-Once vs Exactly-Once Delivery
Attack surface
Attack surface refers to the sum total of all possible entry points an attacker could use to compromise your system.
Lesson 1038 — Minimize Attack Surface
attack tree
An attack tree is a visual diagram that breaks down how an attacker might achieve a specific goal.
Lesson 1082 — Attack Trees and Risk Prioritization
Auditing
Auditing means examining your declared dependencies to understand what's actually being used in your codebase.
Lesson 681 — Dependency Pruning and Auditing
authentication
Think of a hotel: authentication is proving you're a guest (showing your ID at check-in), while authorization is determining which room you can enter (your key card only opens your room, not others).
Lesson 1025 — Authorization Fundamentals: Who Can Do What
authentication factors
Authentication relies on three distinct types of proof, called authentication factors:
Lesson 991 — The Three Factors of Authentication
authorization
Think of a hotel: authentication is proving you're a guest (showing your ID at check-in), while authorization is determining which room you can enter (your key card only opens your room, not others).
Lesson 1025 — Authorization Fundamentals: Who Can Do What
Automated Refactorings
Automated Refactorings are your safest bet.
Lesson 1756 — Preserving Behavior While Changing Structure
availability
Think of it like a local fire station: availability means the station is open and staffed 24/7, while reliability means when you call 911, the equipment works, trucks start, and firefighters actually arrive.
Lesson 131 — Reliability and Availability Requirements
Available but unreliable
The machine is always powered on and accepts your money (high availability), but occasionally gives you the wrong snack or wrong change (low reliability).
Lesson 1241 — Availability and Reliability
axe-core
axe-core is a widely-used JavaScript library that integrates into your E2E or UI tests.
Lesson 582 — Automated Accessibility Testing

B

backing service
A backing service is any service your application consumes over the network—databases, message queues, email services, caching systems, or third-party APIs.
Lesson 750 — Backing Services and Build-Release-Run Factors
Backward compatibility
Backward compatibility means new versions of your software can work with data, configurations, or clients designed for older versions.
Lesson 790 — Why API Versioning MattersLesson 1553 — Version Compatibility and Breaking Changes
Backward recovery
Backward recovery means abandoning the original goal and executing compensating transactions for all previously completed steps.
Lesson 1369 — Forward Recovery vs Backward Recovery
baseline
A baseline is your system's "normal" performance profile—a reference snapshot of latency, throughput, CPU usage, and other metrics when everything is working well.
Lesson 1211 — Baseline Metrics and Regression Detection
Batch Fetching
Batch Fetching is a lazy loading optimization—it loads related data in chunks as accessed.
Lesson 945 — Eager Loading and Fetch Strategies
Behavior verification
Behavior verification is different: it tests how your code interacts with its dependencies, not just what it produces.
Lesson 483 — Behavior Verification: Testing Interactions
Better minimization
The framework can explore the entire space of simpler inputs more systematically
Lesson 619 — Integrated Shrinking
Better partition tolerance
The system continues working during network splits
Lesson 922 — Understanding Eventual Consistency
Better visibility
The coordinator tracks progress, making debugging and monitoring straightforward
Lesson 1375 — Trade-offs: Coupling and Visibility
blackout periods
Release windows are pre-approved time slots when deployments are permitted, while blackout periods are times when releases are prohibited or severely restricted.
Lesson 1548 — Release Windows and Blackout Periods
blast radius
The blast radius is the scope of impact when something goes wrong.
Lesson 719 — Deployment Risk and the Need for Rollback
bottleneck
In Kanban (and Agile in general), a bottleneck is any stage in your workflow where work piles up faster than it can be completed.
Lesson 1597 — Identifying and Resolving Bottlenecks
Boundaries
Boundaries are the limits of valid ranges:
Lesson 604 — Boundary Value and Edge Case Coverage
boundary
The boundary is where one module ends and another begins—the point where they communicate.
Lesson 522 — What Are Module Boundaries
bounded context
A bounded context is an explicit boundary within which a domain model and its ubiquitous language are internally consistent.
Lesson 1306 — Domain-Driven Design Bounded Contexts
Boxes
Boxes are stacked to show which function called which
Lesson 1196 — CPU Profiling and Flame Graphs
Branches
Branches are just movable pointers to commits in the graph
Lesson 65 — Understanding Git History as a DAG
branching strategy
A branching strategy is a shared agreement within your team that defines:
Lesson 82 — What Are Branching Strategies and Why Do They Matter
breaking change
This is called a breaking change: any modification that makes existing client code stop working.
Lesson 790 — Why API Versioning Matters
Breaking changes
Breaking changes are prominently highlighted
Lesson 1555 — Automating Changelog Generation
Breakpoints
Breakpoints are markers you place on specific lines of code.
Lesson 1728 — Debugger Fundamentals: Breakpoints and Execution Control
Bridge
Bridge is like designing a universal remote control from scratch—you intentionally separate the remote's interface (buttons, display) from the TV brands it controls, knowing you'll add support for new brands without redesigning the remote itself.
Lesson 262 — Adapter vs Bridge: Understanding the Distinction
Bugs in production
Bugs in production are exponentially more expensive than bugs caught during development.
Lesson 426 — The Cost of Not Testing
Build agents
Build agents are separate machines or containers that:
Lesson 640 — Build Agents and Executors
Build artifacts
Build artifacts are the outputs of your build process (compiled binaries, test results, packaged applications), while caching saves dependencies and intermediate files so they don't need to be recreated from scratch every time.
Lesson 641 — Build Artifacts and Caching
build configuration file
A build configuration file is a text file you store alongside your code that tells the CI server exactly what to do when someone pushes code.
Lesson 638 — Build Configuration Files
build script
A build script is like following handwritten notes you made yourself—flexible and personal, but you write every step from scratch.
Lesson 659 — Build Scripts vs Build Tools
Build scripts
Build scripts are simple executable files (shell scripts, batch files, Python scripts) you write to automate tasks like compiling code, running tests, or packaging applications.
Lesson 659 — Build Scripts vs Build Tools
Build time
Build time is critical—if builds take 30 minutes, developers stop running them frequently.
Lesson 650 — CI Metrics and Visibility
build tool
A build tool is like a recipe app with pre-programmed functions—it knows common patterns, handles timing automatically, and prevents common mistakes.
Lesson 659 — Build Scripts vs Build Tools
Built-in practices
Code review, automated testing, and monitoring are non-negotiable defaults, not optional extras
Lesson 1832 — Defining Quality Culture
bulkheads
In software, bulkheads are resource partitions that isolate different parts of your system.
Lesson 1105 — Bulkheads and Isolation
Business goals
Business goals are strategic objectives like increasing revenue, reducing time-to-market, entering new markets, or improving customer retention.
Lesson 1233 — Business Goals and Architecture Alignment
Business stakeholders
Business stakeholders are the people who have a vested interest in the project's success: executives, department heads, clients, or investors.
Lesson 21 — The Product Owner and Business Stakeholders
Bypassing the ORM
Bypassing the ORM means writing raw SQL for specific operations.
Lesson 948 — Write Performance and Batch Operations

C

cache key
The cache key is the unique identifier you use to retrieve cached data, like a library card number that retrieves exactly one borrower's record.
Lesson 961 — Cache Keys and Lookup Mechanisms
cache miss
A cache miss means the data must be fetched from the slower underlying source.
Lesson 959 — Cache Hit Ratios and Effectiveness
Cache tags
Cache tags are labels you attach to cache entries when storing them.
Lesson 981 — Tagging and Bulk Invalidation
Cache-Control
Defines how long and under what conditions browsers should cache a resource (e.g., max-age=3600 means cache for one hour)
Lesson 984 — Browser and Client-Side Caching
canary release
A canary release is a deployment technique where you send new code to a tiny fraction of your users first—maybe 5% or even 1%—while the rest continue using the stable version.
Lesson 710 — Canary Releases
Capacity
Capacity is theoretical—how much work your team could do.
Lesson 1656 — Velocity and Capacity Planning
Capacity planning
Capacity planning means calculating how much work your team can realistically handle.
Lesson 1602 — Effective Sprint Planning Practices
card
Each card represents a single work item—a user story, bug fix, feature, or task.
Lesson 1593 — The Kanban Board
Cardinality
Cardinality refers to the number of distinct values in a column.
Lesson 875 — Index Selectivity and Cardinality
Career goals
An engineer aiming for architecture roles needs different guidance than one focused on deep technical specialization or moving toward management.
Lesson 1798 — Tailoring Mentorship Styles
cargo
cargo is Rust's all-in-one solution, praised for its elegant design that handles dependencies, compilation, testing, and documentation out of the box.
Lesson 660 — Common Build Tools Overview
Catch regressions early
A code change might reintroduce a parser bug that fuzzing previously found. Continuous fuzzing detects this immediately.
Lesson 625 — Integrating Fuzzing into CI/CD
Causal consistency
Operations that are causally related are seen in order by all nodes
Lesson 1410 — Consistency Models and the Spectrum
Challenge acknowledgment
Admitting when projects are struggling or behind schedule
Lesson 1828 — Transparency and Open Communication
Change ripple effect
If modifying one class forces changes in 3+ other classes, coupling is too tight
Lesson 183 — Measuring Coupling and Cohesion in Practice
changelog
A changelog is a structured, chronological record of every meaningful modification to your software.
Lesson 1687 — Changelog and Release Notes
CI culture
A CI culture means the entire team shares ownership of build health, treats broken builds as urgent, and integrates frequently without being reminded.
Lesson 651 — Building a CI Culture
CI server
A CI server is the central coordinator that receives build requests when webhooks trigger.
Lesson 640 — Build Agents and Executors
Circuit Breaker
After repeated failures, stop trying for a period to avoid cascading problems, then gradually test if recovery is possible.
Lesson 1090 — Error Recovery and Graceful Degradation
Classes of Service
Classes of Service (CoS) are categories that define how different types of work should be handled, especially based on urgency and business value.
Lesson 1598 — Policies and Classes of Service
Client Credentials Grant
The Client Credentials Grant is for machine-to-machine communication where no user is involved.
Lesson 1020 — Implicit and Client Credentials Grants
Client-Server Separation
Client-Server Separation is a REST architectural principle that mandates keeping the user interface (client) and data storage (server) as independent components.
Lesson 756 — Client-Server Separation
Client-Side Discovery
The client queries a service registry (like Consul or Eureka) directly, receives a list of available service instances, and chooses one to call. The client is responsible for load balancing.
Lesson 1324 — Client-Side vs Server-Side Discovery
Cloning
Cloning is how you download an entire repository—complete with all its history, branches, and files—from a remote location (like GitHub, GitLab, or a company server) to your local machine.
Lesson 54 — Cloning Existing Repositories
code formatter
A code formatter is a tool that automatically restructures your code's appearance according to a predefined set of rules.
Lesson 392 — Code Formatters and Prettier
Code organization
Code organization means structuring your source files and directories in a way that reflects what your program does and how its parts relate to each other.
Lesson 373 — Code Organization and File Structure
code smell
A code smell is a surface-level symptom in your code that suggests something might be wrong underneath—like how a weird smell in your kitchen might indicate spoiled food hidden in the back of the fridge.
Lesson 335 — What Are Code Smells?
Coherence
Coherence means ensuring all cache layers reflect a consistent view of your data.
Lesson 988 — Multi-Layer Cache Coordination
cold start
This entire process is called a cold start.
Lesson 1521 — Cold Starts and Warm Instances
Collaboration Over Silos
Collaboration Over Silos means actively breaking down these barriers.
Lesson 1830 — Collaboration Over Silos
Color Contrast
Users with color blindness or low vision need sufficient contrast between text and backgrounds (WCAG requires 4.5:1 for normal text). Never rely solely on color to convey information—red/green status indicators are meaningless to colorblind users. Use icons, patterns, or text labels alongside color.
Lesson 1929 — Designing for Diverse Abilities
combinator
A combinator is a function that takes one or more generators and combines them into a new, more complex generator.
Lesson 615 — Generators and Combinators
Command Interface
Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
Lesson 291 — Implementing the Command Pattern
commit
A commit is like taking a photograph of your project at a specific moment in time.
Lesson 48 — Committing Changes with 'git commit'
Commits
These are the snapshots you create with git commit. A commit object points to a tree (your project's state), contains metadata (author, date, message), and points to its parent commit(s). This creates the chain you see with git log.
Lesson 50 — Understanding Git Objects: Blobs, Trees, and Commits
Community of Practice
A Community of Practice (CoP) is a voluntary group of engineers from different teams who share a common technical interest or domain—like frontend development, security, databases, or infrastructure.
Lesson 1846 — Building Technical Communities of Practice
Complete audit trail
Every state change is recorded with context—who did what, when, and why.
Lesson 1347 — Event Sourcing Fundamentals
Complex conflict resolution
The system must decide which write "wins" or merge changes
Lesson 1403 — Multi-Leader and Leaderless Replication
Complex data graphs
Complex data graphs are where GraphQL truly excels.
Lesson 826 — When to Choose GraphQL
Complex logic
Areas where bugs are more likely (calculations, conditionals, integrations)
Lesson 428 — Test ROI and Prioritization
Complexity Tolerance
Cache-aside is straightforward—your application controls everything explicitly. Write-through and read-through push logic into infrastructure but require careful setup. Write-behind adds queuing, retry logic, and potential data loss scenarios. Multi-level caching multiplies these considerations.
Lesson 975 — Pattern Selection Trade-offs
components
A reusable library of definitions—schemas for request/response bodies, parameters, headers, and more. Instead of repeating the same "User" object structure everywhere, define it once here and reference it throughout.
Lesson 838 — Anatomy of an OpenAPI Document
Composition
Composition means building objects by combining smaller, independent components—essentially "has-a" relationships.
Lesson 173 — Favor Composition Over Inheritance
Comprehensive coverage
Test edge cases and states that are hard to trigger in full flows
Lesson 565 — Component Testing vs Full Page Testing
Compromise
Compromise means splitting differences to end disagreement—often leaving everyone partially unhappy.
Lesson 1811 — Understanding Consensus vs Compromise
Concrete Commands
Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
Lesson 291 — Implementing the Command Pattern
Concrete Products
the actual classes being instantiated
Lesson 234 — Factory Method Pattern: Intent and Structure
Concurrent system chaos
In distributed systems with multiple servers, some instances might still be running code that expects the new schema while the database is being rolled back.
Lesson 889 — Forward-Only Migration Philosophy
Condition
A boolean expression (e.g., status == "error")
Lesson 1730 — Conditional Breakpoints and Breakpoint Actions
Confidentiality with Limits
Respect proprietary information and trade secrets, but this duty has boundaries. If you discover your employer is violating laws, harming users, or creating dangerous systems, whistleblowing may be ethically required despite confidentiality agreements.
Lesson 1896 — Client and Employer Obligations
configuration drift
One server gets a manual patch, another has slightly different configuration files—this is called configuration drift.
Lesson 1472 — The Concept of Immutable Infrastructure
Configuration Management
Configuration Management means applying tenant-specific settings: feature flags, billing tiers, localization preferences, and custom branding.
Lesson 1533 — Tenant Onboarding and Provisioning
Connection pooling
Connection pooling means maintaining a collection of already-established connections to backend servers that can be reused across multiple requests.
Lesson 1395 — Connection Pooling and Keep-Alive
Consensus
Consensus means everyone genuinely understands and supports the decision, even if it wasn't their first choice.
Lesson 1811 — Understanding Consensus vs Compromise
Consistency
The same container runs identically everywhere
Lesson 1423 — What Are Containers and Why Use Them
Consistency guarantee
The next read always gets truth from the database
Lesson 979 — Cache-Aside Invalidation Pattern
Consistency Needs
If you need strong consistency (financial transactions, inventory counts), write-through ensures cache and database stay in sync. If eventual consistency is acceptable (social media feeds, view counts), write-behind or cache-aside with TTL-based expiration offers better performance.
Lesson 975 — Pattern Selection Trade-offs
Consistent resource identification
Resources are identified by URLs (/users/123)
Lesson 759 — Uniform Interface Principle
Constraints
Constraints are the hard boundaries you must work within—things you cannot change.
Lesson 132 — Constraints and Assumptions
Consumers
Consumers are components that listen for specific events and react accordingly.
Lesson 1340 — Event Producers and Consumers
container
A container is a lightweight, standalone executable package that bundles application code together with all its dependencies—libraries, runtime, system tools, and configuration files—into a single isolated unit.
Lesson 1423 — What Are Containers and Why Use Them
container registry
A container registry is a centralized repository for storing and distributing container images.
Lesson 1430 — Container Registries
container runtime
While container images define what should run, the container runtime is the low-level software responsible for actually running containers.
Lesson 1426 — The Container RuntimeLesson 1443 — Kubernetes Architecture Overview
containerd
A higher-level runtime that manages runc and handles image operations
Lesson 1426 — The Container Runtime
Content negotiation
Content negotiation is elegant but harder to debug.
Lesson 848 — API Versioning Strategies
Context changes
A variable named user now holds multiple users
Lesson 348 — Rename Method and Rename Variable
Context propagation
Context propagation means attaching identifying information (typically a correlation ID or request ID) to every log statement related to the same logical operation.
Lesson 1132 — Context Propagation in LogsLesson 1147 — Traces, Spans, and Context Propagation
Continuous Delivery
Continuous Delivery means every code change that passes automated tests is packaged and ready for production deployment.
Lesson 15 — DevOps and Continuous Delivery in the SDLCLesson 692 — Continuous Delivery vs Continuous Deployment
Contributing factors
Contributing factors are conditions, circumstances, or weaknesses that enabled the failure to occur or made it worse.
Lesson 1746 — Contributing Factors vs. Root Causes
Control
Self-hosting gives you complete configuration freedom and direct access to underlying infrastructure. Managed services impose constraints—you can't tune kernel parameters or install custom extensions. This reduced control is sometimes the cost of simplicity.
Lesson 1518 — Evaluating Managed Service Trade-offs
Control flow
Control flow is the path your program takes when it runs—which function calls which, where data moves at runtime.
Lesson 224 — The Dependency Flow vs Control Flow
Controller Manager
Runs multiple controllers that continuously monitor the cluster's state. If you requested 3 replicas of a container but only 2 are running, a controller detects this and creates the third.
Lesson 1443 — Kubernetes Architecture Overview
Core business logic
The foundation everything else builds on
Lesson 42 — Balancing Debt and Delivery
core dump
A core dump is a snapshot of your program's memory at the moment it crashed—like a freeze-frame of everything that was in RAM.
Lesson 1734 — Post-Mortem Debugging with Core Dumps and Crash Reports
Core needs
The fundamental problems you're solving (e.g., "Users must authenticate before accessing data")
Lesson 165 — Building Flexibility into Requirements
cost of delay
In software engineering, cost of delay is the financial impact of not shipping a feature or product on time.
Lesson 34 — The Cost of Delay and Opportunity Cost
Coverage-guided fuzzing
Coverage-guided fuzzing is smarter: it monitors which parts of your code each input reaches, then evolves inputs that discover new code paths.
Lesson 622 — Coverage-Guided Fuzzing
covering composite index
A covering index (also called a covering composite index) is an index that includes every column referenced in a query—not just the columns in the WHERE clause, but also those in the SELECT list and any ORDER BY or GROUP BY clauses.
Lesson 874 — Covering Indexes
CPU limits
Restrict CPU shares or cores (e.g., 0.5 CPUs means half a core's worth of time).
Lesson 1438 — Container Resource Limits and Health Checks
Creation logic changes frequently
The "how" of building objects evolves, and you want to isolate those changes
Lesson 242 — Factory Pattern Trade-offs
Critical bugs
Critical bugs are causing production outages or data corruption
Lesson 1568 — What are Hotfixes and When to Use Them
critical path
The critical path is the longest chain of dependent tasks—the minimum time your project will take even with infinite engineers.
Lesson 1664 — Parallel vs Sequential WorkLesson 1669 — Critical Path and Slack Time
Critical paths
Critical paths are the core workflows users depend on.
Lesson 402 — What to Test: Risk-Based Testing
cross-cutting concerns
These are called cross-cutting concerns because they literally cut across all your carefully drawn layer boundaries.
Lesson 1260 — Cross-Cutting Concerns in Layers
cryptographic hash function
A cryptographic hash function is a mathematical algorithm that transforms any input (like a password) into a fixed-size string of characters called a "digest" or "hash." Think of it like a meat grinder: you can turn a steak into ground beef, but you can't reconstruct the original steak from the ground meat.
Lesson 1000 — Cryptographic Hash Functions for Password Storage
Customer collaboration
Customer collaboration means treating your stakeholders as ongoing partners throughout development, not just at the contract-signing and delivery phases.
Lesson 1578 — Customer Collaboration Over Contract Negotiation
Customer empathy
The team viscerally understands how quality affects real users
Lesson 1832 — Defining Quality Culture
customer stakeholders
In software engineering, end users are the people who actually interact with your software to get their work done, while customer stakeholders are often the decision-makers who purchase or approve the software.
Lesson 22 — End Users and Customer Stakeholders
Cycle time
Cycle time is the duration from when a team starts working on an item until it's marked "Done."
Lesson 1595 — Managing Flow and Cycle Time

D

dark launching
Shadow deployment (also called dark launching or shadow testing) means running a new version of your software alongside the current production version, feeding it real user traffic, but discarding its responses.
Lesson 713 — Shadow Deployment
Dashboard Links
Include direct links to pre-filtered dashboards showing the relevant metrics. If CPU is spiking, link to the CPU dashboard for that specific service and time window.
Lesson 1160 — Alert Context: Including Diagnostic Information
Data Coupling
Data Coupling means Service A directly queries Service B (or its database) for that data.
Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
Data Duplication
Data Duplication means Service A stores its own copy of data that originates in Service B.
Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
Data formats
Storing data in vendor-specific formats or schemas
Lesson 1539 — What is Vendor Lock-in
Data hiding
Data hiding means restricting direct access to that data from outside code.
Lesson 171 — Encapsulation and Data Hiding
data isolation
In a multi-tenant system, data isolation is your insurance policy against catastrophic breaches.
Lesson 1531 — Data Isolation Strategies
Data Ownership
Each microservice typically manages its own database or data store. No shared database means no hidden coupling through data access.
Lesson 1294 — Defining Microservices
Data Transfer Object
A Data Transfer Object is a simple, flat data structure with no business logic — just fields and basic getters/setters.
Lesson 1278 — Crossing Boundaries with DTOs
Database Layer
The last resort. Some databases support row-level security or view-based restrictions. This protects against bugs or compromised application code, but shouldn't be your primary authorization mechanism—it's slow and hard to express complex rules in SQL.
Lesson 1030 — Implementing Authorization in Applications
Database Per Service Pattern
In microservices architecture, the Database Per Service Pattern means each service manages its own dedicated database that no other service can access directly.
Lesson 1307 — Database Per Service Pattern
Debugging Confidence
If you can't reproduce a build, you can't truly know what's running in production. Reproducibility means your local debugging environment matches reality.
Lesson 691 — Benefits and Trade-offs
Declarative configuration
Declarative configuration is like giving a destination: "Take me to 123 Main Street." The system figures out how to get there from wherever you currently are.
Lesson 1489 — Declarative vs Imperative Configuration
Declarative provisioning
Declarative provisioning is like ordering from a menu: "I want lasagna." You describe the desired end state, and the system figures out how to get there.
Lesson 1480 — Declarative vs Imperative Provisioning
Decompose Conditional
Decompose Conditional means extracting both the conditional expression and its resulting actions into separate, well-named methods.
Lesson 355 — Decompose Conditional
Decorator
Decorator is more flexible—infinite combinations without new classes.
Lesson 271 — Decorator vs. Inheritance: Flexibility and Complexity
Decoupling
Producers don't need to know which consumer will handle their message, or even if consumers are currently online. The queue handles delivery guarantees.
Lesson 1359 — Message Queues and Point-to-Point Messaging
Dedicated Learning Time
Many teams allocate 10-20% of sprint capacity for learning—reading, experimentation, or skill development. Google's "20% time" is the famous example, but even small teams can protect Friday afternoons for exploration.
Lesson 1840 — Creating a Culture of Continuous Learning
Default Values
Return sensible defaults instead of crashing—show a generic profile picture if the image service is down.
Lesson 1090 — Error Recovery and Graceful Degradation
Defense in depth
Defense in depth means never relying on a single security control.
Lesson 1069 — Defense in Depth for Cross-Site Attacks
Defensive Programming
Defensive Programming means anticipating problems and handling them gracefully.
Lesson 176 — Fail Fast and Defensive Programming
Definition of Done
The Definition of Done (DoD) is a checklist or set of criteria that every work item—whether a user story, task, or feature—must satisfy before it's considered complete.
Lesson 1591 — Definition of Done
DELETE
Idempotent but not safe. Deleting a resource once removes it; deleting it again still leaves it deleted (404s are acceptable).
Lesson 765 — Safe and Idempotent Methods
Deliverables
Deliverables are the tangible outputs you produce: working features, documentation, deployed systems, or test reports.
Lesson 1659 — Identifying Milestones and Deliverables
Demonstrated Expertise
Show depth in areas that matter to your team. This doesn't mean knowing everything; it means having deep knowledge where it counts and knowing your limits elsewhere. Answer questions thoroughly, explain trade-offs clearly, and share insights that others miss.
Lesson 1795 — Building Technical Credibility
Denial of Service
Inputs that cause crashes, infinite loops, or excessive resource consumption are security issues. Fuzzing finds them by generating pathological cases.
Lesson 624 — Detecting Security Vulnerabilities
Dependency direction
Dependency direction refers to which components depend on which others.
Lesson 189 — Dependency Direction and Stability
Dependency flow
Dependency flow is about which modules or files know about (depend on) other modules at compile-time.
Lesson 224 — The Dependency Flow vs Control Flow
Dependency registers
Dependency registers are living documents (spreadsheets, project management tools, or wikis) that list each dependency, its owner, expected completion date, and current health status.
Lesson 1672 — Tracking and Communicating Dependency Status
Dependency unavailability
Dependency unavailability means an external service you rely on is either:
Lesson 1108 — Handling Dependency Unavailability
Deployable
The code can be packaged, deployed, and run in production-like environments. Build processes complete successfully, and deployment scripts work without manual intervention.
Lesson 694 — Production-Ready Definition
deployment pipeline
A deployment pipeline is an automated process that takes every code change from commit to production-ready state through a series of increasingly rigorous environments and tests.
Lesson 693 — The Deployment Pipeline Concept
Deprecated
The decision is no longer recommended but may still be in use
Lesson 1703 — ADR Status and Lifecycle
Deprecation
Deprecation is the formal process of announcing that a feature, function, or version is scheduled for removal or no longer recommended.
Lesson 676 — Deprecation and Version Lifecycle
Deprecation warnings
Mark features as deprecated in documentation, release notes, and ideally in code (like log warnings). Explain what is deprecated, why, and when it will be removed.
Lesson 676 — Deprecation and Version Lifecycle
Detection
An alert fires or someone notices something wrong. This is where your monitoring and alerting setup (covered in previous lessons) kicks in. The faster detection happens, the smaller the impact.
Lesson 1165 — Incident Response Workflow
development
Profiling in development is like practicing with training wheels—you can use heavyweight tools, run them continuously, and experiment freely because user impact doesn't matter.
Lesson 1199 — Profiling in Production vs Development
Difficult to test
Testing one giant method means testing everything it does at once. You can't easily test individual pieces of logic in isolation.
Lesson 336 — Bloaters: Long Method
Digital stewardship
Digital stewardship means recognizing that your code doesn't just serve this sprint's goals—it shapes infrastructure, behaviors, and ecosystems that may outlive your tenure at the company.
Lesson 1933 — Long-term Thinking and Digital Stewardship
Diminishing returns
For simple CRUD APIs or internal services, Level 2 is often sufficient
Lesson 797 — HATEOAS Trade-offs and Maturity Models
Direct Instantiation
Direct Instantiation means calling a constructor yourself:
Lesson 235 — Factory Method vs Direct Instantiation
Directed
The connections have arrows—they point from one node to another
Lesson 65 — Understanding Git History as a DAG
dirty reads
This means you might see changes that could be rolled back—these are called dirty reads.
Lesson 905 — Read Uncommitted Isolation
Discipline
Discipline means actually doing these things every time, even when you're tired, rushed, or convinced "this small change doesn't need tests."
Lesson 6 — Process and Discipline
Discovery work
The time spent understanding a problem is itself hard to estimate
Lesson 1648 — Why Estimation is Hard
Disparate treatment
Disparate treatment means explicitly using protected attributes in decisions—easier to spot but often hidden in proxy variables (ZIP code correlating with race, for example).
Lesson 1915 — Evaluating Models for Bias
Distributed failures
Failures are harder to detect because no central observer exists
Lesson 1375 — Trade-offs: Coupling and Visibility
Diverse client needs
Diverse client needs are GraphQL's primary strength.
Lesson 826 — When to Choose GraphQL
Documentation
The file itself documents what the pipeline does
Lesson 708 — Pipeline as Code
Documentation as Code
Documentation as Code means storing your documentation files (often Markdown, AsciiDoc, or similar formats) directly in your project's version control repository alongside your source code.
Lesson 1706 — Documentation as Code
Documentation generators
Documentation generators are tools that automatically extract specially-formatted comments from your code and transform them into beautiful HTML pages, PDFs, or interactive websites.
Lesson 379 — Documentation Tools and Standards
Domain alignment
The boundary follows natural divisions in your business domain, not technical convenience
Lesson 1290 — Defining Module Boundaries
domain event
A domain event is a record of something meaningful that happened in your system — like "Order Placed," "Payment Completed," or "Inventory Reserved." When one bounded context needs to know about changes in another, domain events provide a clean way to communicate without direct dependencies.
Lesson 1285 — Domain Events for Context Integration
Domain terminology
The exact words professionals use, so your requirements match their mental models
Lesson 140 — Domain Research and Competitive Analysis
Dual licensing
Dual licensing means offering the same code under two (or more) different licenses simultaneously.
Lesson 1876 — Dual Licensing and License Exceptions
Dummies
Dummies are perfect when you need to satisfy a function signature but the parameter isn't actually used in your test scenario.
Lesson 472 — When to Use Each Type of Test Double
dummy object
A dummy object is the simplest form of test double—it's passed as an argument to satisfy a method's parameter list, but it's never actually used within the test.
Lesson 465 — Dummy Objects: The Simplest Test Double
Duplicated Data
Duplicated Data means copying information from one table into another to avoid joins.
Lesson 866 — Denormalization Patterns

E

E2E tests
E2E tests are like driving the car from your house to the grocery store and back—testing everything together in real-world conditions
Lesson 407 — The Testing Pyramid ConceptLesson 554 — What is End-to-End Testing
Early wins
Begin with configuration management (Factor III) and dependency management (Factor II)—these are low-hanging fruit that prevent common production issues
Lesson 754 — Applying Twelve-Factor Principles in Practice
Easier debugging
Small scope means fewer variables to investigate
Lesson 526 — Narrow Integration Tests
Easy setup
Fewer dependencies means simpler test data requirements
Lesson 565 — Component Testing vs Full Page Testing
Edge cases
Edge cases are unusual but valid scenarios:
Lesson 604 — Boundary Value and Edge Case Coverage
Edge locations
Edge locations are data centers positioned strategically around the world.
Lesson 985 — CDN and Edge Caching
Efficient Code
Efficient Code means choosing algorithms and data structures wisely.
Lesson 1932 — Sustainable Software Engineering Practices
Email notifications
Email notifications are the traditional approach—send build results to individuals or team lists.
Lesson 643 — Build Notifications and Reporting
EmailValidator
a thing that validates (the validator itself)
Lesson 369 — Class and Type Naming
Emergent design
Emergent design means starting with minimal structure and letting better patterns reveal themselves through the red-green-refactor cycle.
Lesson 512 — Emergent Design vs. Upfront Design
Enables reuse
the new object can be used elsewhere
Lesson 353 — Introduce Parameter Object
Encapsulation
Encapsulation means bundling related data and the methods that work with that data into a single unit (like a class or module).
Lesson 171 — Encapsulation and Data Hiding
End Users
In software engineering, end users are the people who actually interact with your software to get their work done, while customer stakeholders are often the decision-makers who purchase or approve the software.
Lesson 19 — Who Are Stakeholders?Lesson 22 — End Users and Customer Stakeholders
End-to-end tests
End-to-end tests are expensive—they can take minutes to run, require full system setup, and break whenever UI or workflows change.
Lesson 409 — The Cost-Confidence Trade-off
Enforce consistency
The tool continuously checks and corrects drift
Lesson 1488 — Introduction to Configuration Management
Entities
Entities are the innermost layer of Clean Architecture—they contain the core business logic that would exist even if you never built any software.
Lesson 1274 — Entities: Enterprise Business Rules
Environment variables
Environment variables are the primary way to inject this configuration at runtime without rebuilding images.
Lesson 642 — Environment Variables and SecretsLesson 734 — Configuration Files vs Environment VariablesLesson 1436 — Environment Variables and Configuration
Equal trade-offs
Multiple options are genuinely equivalent, but paralysis persists
Lesson 1816 — Making Decisions When Consensus Fails
error budget
An error budget is the amount of unreliability your service can tolerate before violating its SLO (Service Level Objective).
Lesson 1175 — The Error Budget Concept
Error handling gaps
Untested catch blocks, error callbacks, or validation paths are red flags. These are precisely the code paths that execute when things go wrong—critical to test.
Lesson 594 — Reading Coverage Reports
Error recovery
Error recovery means detecting a problem and automatically correcting it, allowing the system to return to normal operation.
Lesson 1090 — Error Recovery and Graceful Degradation
Errors
Errors are predictable problems that are part of normal operation.
Lesson 1084 — Errors vs Exceptions vs Failures
ETag
A version identifier that lets browsers check if their cached copy is still current without downloading the whole file again
Lesson 984 — Browser and Client-Side Caching
event bus
An event bus is a publish-subscribe pattern where events are broadcast to all interested subscribers without the publisher knowing who's listening.
Lesson 1357 — Message Brokers vs Event Buses: Core Concepts
Event Channel
The infrastructure (message queue, event stream) that routes events from producers to consumers
Lesson 1338 — What is Event-Driven Architecture
Event-driven workloads
Event-driven workloads are serverless's sweet spot.
Lesson 1527 — When Serverless is and Isn't Appropriate
Exactly-Once
The event is delivered precisely one time. The holy grail, but incredibly difficult (sometimes impossible) to guarantee end-to-end in distributed systems.
Lesson 1344 — At-Least-Once vs Exactly-Once Delivery
Examine the critical path
Trace the sequence of spans from start to finish. Spans that block other work are more important than parallel operations.
Lesson 1151 — Analyzing Traces for Performance Issues
Exceptions
Exceptions are unexpected but recoverable conditions that disrupt the normal flow of execution.
Lesson 1084 — Errors vs Exceptions vs Failures
Excessive data transfer
Retrieving entire datasets when only a subset is needed
Lesson 1198 — I/O and Network Profiling
Execution steps
The exact SQL or migration command
Lesson 895 — Testing and Reversibility
Experience level
A junior developer might need more structured guidance and explicit examples, while a senior engineer benefits from thought-provoking questions that help them discover solutions independently.
Lesson 1798 — Tailoring Mentorship Styles
Expires
An older header specifying an absolute expiration date
Lesson 984 — Browser and Client-Side Caching
Exposure through process listings
On many systems, environment variables are visible to other processes. Commands like ps -e on Linux can reveal them to anyone with system access.
Lesson 742 — Secrets in Environment Variables
External Services
This is where boundaries get fuzzy. For critical third-party services (payment processors, authentication providers), consider using their sandbox/test environments. For less critical services, mocks or stubs might be appropriate to avoid flakiness and cost.
Lesson 556 — E2E Test Scope and Boundaries
Externalizing state
Externalizing state means moving session and transient data out of your application servers into shared, dedicated systems that all servers can access:
Lesson 1394 — Externalizing State
Extract Class
Extract Class means taking a subset of fields and methods from an oversized class and moving them into a new, separate class.
Lesson 350 — Extract Class and Inline Class
Extrinsic state
Extrinsic state is the data that's unique to each usage context.
Lesson 275 — Intrinsic vs Extrinsic State in Flyweight

F

Face-to-face conversation
Face-to-face conversation is the most efficient communication method
Lesson 1580 — The Twelve Principles Behind the Agile Manifesto
Factory Method
Factory Method means asking a method to create the object for you:
Lesson 235 — Factory Method vs Direct Instantiation
Fail Fast
Fail Fast means detecting problems as early as possible and stopping immediately.
Lesson 176 — Fail Fast and Defensive Programming
fail-secure
Fail-safe and fail-secure are two philosophies for making that choice, and picking the right one depends on what you're protecting.
Lesson 1107 — Fail-Safe and Fail-Secure Defaults
Failures
Failures are catastrophic, unrecoverable problems that compromise system integrity.
Lesson 1084 — Errors vs Exceptions vs Failures
fake
A fake is a test double that actually works—it's a real, functioning implementation, just simpler than the production version.
Lesson 467 — Fakes: Working Implementations for Testing
Fallback to Alternative
If one payment gateway fails, try another. If the primary database is down, read from a replica.
Lesson 1090 — Error Recovery and Graceful Degradation
False confidence
Teams believe their code is well-tested when it isn't
Lesson 599 — The Danger of Coverage Theater
Faster execution
Fewer real components means less setup overhead
Lesson 526 — Narrow Integration Tests
Feature branching
Feature branching means developers create separate branches for each feature, merging back to main only when complete—sometimes after days or weeks.
Lesson 646 — Working on the Trunk vs Feature Branches
Feature Flags
Since incomplete features get merged into trunk, teams use feature flags (toggles) to hide work-in-progress from users. The code is there, but turned "off" until ready.
Lesson 83 — Trunk-Based Development
feedback loop
In the SDLC, a feedback loop is when you use information discovered in a later phase to inform and improve decisions made in earlier phases.
Lesson 17 — Feedback Loops Across the SDLC
Final shutdown
After the deadline, return 410 Gone status codes indicating the resource is permanently unavailable, with links to migration documentation.
Lesson 853 — API Sunset and End-of-Life
Fitness functions
These are automated checks that protect important architectural characteristics during evolution. If you value performance, you'd have tests that fail if response times degrade. If you value modularity, you'd have tools that prevent unwanted dependencies between components.
Lesson 1227 — Evolutionary Architecture
Flag debt
Flag debt is the accumulation of obsolete or stale feature flags in your codebase—similar to technical debt.
Lesson 1566 — Flag Debt and Cleanup Strategies
flaky test
A flaky test is one that sometimes passes and sometimes fails—without any code changes.
Lesson 656 — Flaky Test Management
flame graph
A flame graph is a visualization that shows the entire call stack hierarchy and how much CPU time each function consumed.
Lesson 1196 — CPU Profiling and Flame Graphs
flow
In Kanban, flow refers to the smooth, continuous movement of work items through your process.
Lesson 1595 — Managing Flow and Cycle Time
Flux
Flux is a lightweight, Kubernetes-native operator that monitors Git repositories and Helm releases.
Lesson 1498 — GitOps Tools and Operators
Focused
Only the methods that are actually needed
Lesson 508 — Designing Testable Interfaces
Forward compatibility
Forward compatibility means old versions can handle artifacts from newer versions gracefully.
Lesson 1553 — Version Compatibility and Breaking Changes
Forward recovery
Forward recovery means persisting through the failure by retrying the failed step, possibly with exponential backoff or adjusted parameters.
Lesson 1369 — Forward Recovery vs Backward Recovery
Frameworks and Drivers Layer
The Frameworks and Drivers Layer is the most external circle in Clean Architecture.
Lesson 1277 — Frameworks and Drivers Layer
Frequent Integration
Developers integrate their code into the trunk multiple times per day. This means everyone always sees the latest changes from the team.
Lesson 83 — Trunk-Based Development
Frontend
Always include your actual UI—the buttons, forms, and pages users interact with. This is non-negotiable for true E2E testing.
Lesson 556 — E2E Test Scope and Boundaries

G

Gates
Gates are decision points between stages.
Lesson 700 — Anatomy of a Deployment Pipeline
gauge
A gauge represents a value that can go up or down arbitrarily.
Lesson 1139 — Counter, Gauge, and Histogram Metrics
generator
A generator is a function that produces random test values (like integers, strings, or booleans).
Lesson 615 — Generators and Combinators
Geographic distribution
Cross-datacenter or cross-region links are particularly vulnerable
Lesson 1407 — Network Partitions in Practice
Git
Git is a distributed version control system created by Linus Torvalds in 2005.
Lesson 43 — What is Version Control and Why Git?
God Object
A Large Class (sometimes called a God Object) is a class that has grown so big it's doing far too many things.
Lesson 337 — Bloaters: Large Class and God Object
good design
Think of it like furniture assembly instructions: good design means the pieces fit together obviously (self-documenting), but you still need warnings like "Don't overtighten bolt C—it will crack the frame" (comments for non-obvious details).
Lesson 375 — Self-Documenting Code vs Comments
Graceful degradation
Graceful degradation means acknowledging that full functionality isn't available, but providing a reduced, still-useful experience instead of complete failure.
Lesson 1090 — Error Recovery and Graceful Degradation
Graph
A collection of nodes (points) connected by edges (lines)
Lesson 65 — Understanding Git History as a DAG
Green Hosting
Green Hosting means selecting cloud providers powered by renewable energy.
Lesson 1932 — Sustainable Software Engineering Practices
Growing systems
traffic doubles yearly; yesterday's "high" is today's normal
Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
guard clause
A guard clause is a conditional check at the beginning of a method that handles a special case and returns immediately.
Lesson 354 — Replace Nested Conditionals with Guard Clauses

H

Handler Interface
Defines how requests are received and optionally passed to the next handler.
Lesson 287 — Chain of Responsibility Pattern: Core Concept
health check
A health check is an endpoint (typically /health or /actuator/health) that your service exposes.
Lesson 1326 — Health Checks and Registration
Health Checks
These are simple endpoints or tests that verify your application is responding correctly. If health checks start failing after deployment, that's a clear signal something's broken.
Lesson 722 — Monitoring and Automated Rollback Triggers
Health-Aware Routing
Don't just know where services are—know which instances are healthy. Route traffic only to instances passing health checks.
Lesson 1116 — Fallacy 5: Topology Doesn't Change
heap dump
A heap dump is a snapshot of all live objects in memory at a specific moment.
Lesson 1197 — Memory Profiling and Heap Analysis
High change frequency
The code changes often (new features, bug fixes). Refactoring reduces future maintenance costs significantly.
Lesson 1765 — The Economics of Legacy Refactoring
High cohesion
High cohesion means the methods and data in a class work together toward a single, well-defined purpose.
Lesson 182 — The Relationship Between Coupling and CohesionLesson 197 — Cohesion and SRP
High throughput approach
The kitchen batches orders, cooking multiple steaks simultaneously. More customers fed per hour, but each individual waits longer.
Lesson 1204 — Latency vs Throughput
High WIP in one column
If "In Review" consistently hits its WIP limit while "Development" is empty, reviews are your bottleneck.
Lesson 1597 — Identifying and Resolving Bottlenecks
Higher availability
Systems remain responsive even when some nodes are unreachable
Lesson 922 — Understanding Eventual Consistency
Hook methods
Hook methods are those optional steps—they provide default (often empty) behavior that subclasses can choose to customize.
Lesson 316 — Hook Methods in Template Method
hotfix
A hotfix is an emergency code change deployed directly to production, bypassing your standard release process.
Lesson 1568 — What are Hotfixes and When to Use Them
how it handles failures
But in performance engineering, how often your system fails and how it handles failures are critical performance dimensions.
Lesson 1209 — Error Rate and Success Metrics
HTTP Strict Transport Security
HTTP Strict Transport Security is a security header your server sends that instructs browsers: "For the next X seconds, only communicate with me over HTTPS, even if the user types http:// or clicks an HTTP link."
Lesson 1071 — HTTP Strict Transport Security (HSTS)
Hypothesis
Hypothesis (Python) is the most feature-rich modern implementation.
Lesson 613 — Property Testing Tools and Frameworks

I

Idempotence
Idempotence means applying an operation multiple times has the same effect as applying it once.
Lesson 609 — Common Property Patterns
Idempotency
Idempotency means running the same playbook multiple times produces the same result without unintended side effects.
Lesson 1490 — Ansible Fundamentals
Identifying actionable improvements
Identifying actionable improvements means translating your root cause analysis into specific, measurable tasks that close the gaps revealed by the incident.
Lesson 1184 — Identifying Actionable Improvements
Immutability
Immutability is important (build once, never change)
Lesson 246 — Builder vs Constructor: When to Use Each
immutable artifact
An immutable artifact is a packaged version of your application that contains everything needed to run: the application code, runtime dependencies, libraries, configuration files, and even the operating system components.
Lesson 1475 — Building Immutable Artifacts
Imperative configuration
Imperative configuration is like giving turn-by-turn directions: "Go straight, turn left at the light, then right after the bridge." You specify the exact sequence of steps to execute.
Lesson 1489 — Declarative vs Imperative Configuration
Imperative provisioning
Imperative provisioning is like giving step-by-step cooking instructions: "First, preheat the oven to 350°F.
Lesson 1480 — Declarative vs Imperative Provisioning
Implementation
Implementation is the actual carpentry, wiring, and painting.
Lesson 1219 — Defining Software Architecture
Improve query performance
The database can scan a smaller, more focused index with higher selectivity
Lesson 876 — Partial and Filtered Indexes
Improves Readability
A method named calculateTotalWithTax() tells you immediately what it does. Five lines of arithmetic scattered in your code forces readers to decode your intent.
Lesson 346 — Extract Method
Incomplete transactions
A user update fails halfway through, leaving elevated privileges in place
Lesson 1034 — Fail Securely
Increased Abstraction
Patterns add layers between your intent and implementation. Instead of directly creating an object, you might use a Factory. Instead of calling a method, you might dispatch a Command. Each layer is one more thing to understand.
Lesson 323 — The Cost of Pattern Overhead
Increasing cycle time
If tasks suddenly take longer to complete, measure time spent in each stage. The stage with growing wait times is likely your constraint.
Lesson 1597 — Identifying and Resolving Bottlenecks
Independence
Service A runs even if Service B is down
Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
Independent Deployment
You can update, deploy, and scale one service without touching others. This is the fundamental difference from modular monoliths where modules deploy together.
Lesson 1294 — Defining Microservices
index
An index is a separate data structure that maintains an organized copy of specific columns from your table, along with pointers to where the full rows live.
Lesson 869 — What Indexes Are and How They Work
Information hiding
Information hiding means keeping implementation details private, so other parts of your system don't depend on them.
Lesson 167 — Abstraction and Information Hiding
Infrastructure as Code
Infrastructure as Code is the practice of managing and provisioning computing infrastructure through machine-readable configuration files rather than manual processes or interactive configuration tools.
Lesson 1464 — What is Infrastructure as Code
Ingress
An Ingress is a Kubernetes resource that defines rules for routing external HTTP/S traffic to internal Services.
Lesson 1463 — Ingress Controllers and HTTP Routing
Ingress Controller
An Ingress Controller is the actual component that implements these rules.
Lesson 1463 — Ingress Controllers and HTTP Routing
Inheritance
Inheritance means creating a parent-child relationship where the child "is-a" type of parent and inherits all its behaviors.
Lesson 173 — Favor Composition Over InheritanceLesson 271 — Decorator vs. Inheritance: Flexibility and Complexity
Injection Flaws
SQL injection, command injection, and script injection happen when untrusted input is incorporated into queries or commands. Fuzzing with special characters ('; DROP TABLE--, $(rm -rf /)) exposes insufficient sanitization.
Lesson 624 — Detecting Security Vulnerabilities
Inline Class
Inline Class is the reverse: when a class is doing so little that it doesn't justify existing separately, you fold its responsibilities back into another class.
Lesson 350 — Extract Class and Inline Class
input domain
The input domain is the complete set of all valid inputs your function should handle.
Lesson 610 — Generators and Input Domains
Insider threats
A malicious employee can abuse their complete access
Lesson 1037 — Separation of Duties
Integrated
The code successfully integrates with the rest of the system. It's been merged into the mainline branch, and all integration points work correctly with other components.
Lesson 694 — Production-Ready Definition
Integration tests
Integration tests are like checking that your car's engine connects properly to the transmission
Lesson 407 — The Testing Pyramid ConceptLesson 554 — What is End-to-End Testing
Intent locks
Intent locks are lightweight locks placed at higher levels of a hierarchy (like tables or pages) to signal that finer-grained locks (like row locks) exist or are needed below.
Lesson 920 — Intent Locks and Lock Hierarchies
interactors
In Clean Architecture, use cases (also called interactors) represent your application's specific business rules—the workflows and scenarios your system performs.
Lesson 1275 — Use Cases: Application Business Rules
Interface Definition Language
An Interface Definition Language (IDL) is a specification format that describes the interface of a service—what methods it offers, what parameters they accept, and what they return—in a language-agnostic way.
Lesson 800 — Interface Definition Languages (IDLs)
Internal fragmentation
Pages are only partially filled, wasting space
Lesson 877 — Index Maintenance and Statistics
Intervention
Intervention means addressing exclusionary behavior in the moment.
Lesson 1854 — Allyship and Advocacy in Engineering
Interviews
Interviews are your most powerful tool for depth.
Lesson 1674 — Understanding Stakeholder Needs and Concerns
Intrinsic state
Intrinsic state is the data that can be shared across many objects.
Lesson 275 — Intrinsic vs Extrinsic State in Flyweight
Introduce Parameter Object
Introduce Parameter Object means creating a new class or struct to hold related parameters, then passing that single object instead.
Lesson 353 — Introduce Parameter Object
invalidation pattern
The invalidation pattern means that whenever you modify data in the primary data store (database), you explicitly delete the corresponding cache entry rather than updating it.
Lesson 979 — Cache-Aside Invalidation Pattern
Invariants
Invariants are conditions that must always hold true for the object's state.
Lesson 209 — Behavioral Subtyping and ContractsLesson 609 — Common Property Patterns
Invoker
Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
Lesson 291 — Implementing the Command Pattern
Isolating the problem domain
Isolating the problem domain means systematically determining which layer or component is responsible for the failure.
Lesson 1723 — Isolating the Problem Domain
It's easier to test
Fewer unrelated concerns means simpler, focused tests
Lesson 180 — Understanding Cohesion: What Belongs Together
It's more reusable
A focused module can be used elsewhere without dragging along unrelated baggage
Lesson 180 — Understanding Cohesion: What Belongs Together
Its own network namespace
a private networking environment with its own network interfaces, routing tables, and IP addresses
Lesson 1428 — Container Networking Basics

K

Kanban board
A Kanban board is a visual tool that makes work visible and tracks progress through defined stages.
Lesson 1593 — The Kanban Board
key-value pairs
While structured logging gives you machine-readable format (like JSON), key-value pairs are what you actually put inside that structure.
Lesson 1130 — Key-Value Pairs and Log Fields
kill switch
A kill switch is a flag designed to instantly disable a problematic feature without deploying new code.
Lesson 1567 — Advanced Patterns: Kill Switches and Experiments
Knowledge Barriers
New team members struggle to understand the system because everything is interconnected. There's no clear boundary where one responsibility ends and another begins.
Lesson 179 — The Cost of Tight Coupling
Known short-term needs
A feature needed for one event, then retired
Lesson 42 — Balancing Debt and Delivery
Kubelet
An agent that ensures containers are running as specified. It receives Pod specifications from the API server and manages the containers on its node using the container runtime.
Lesson 1443 — Kubernetes Architecture Overview
Kubernetes Service Discovery
Kubernetes Service Discovery is more sophisticated.
Lesson 1329 — DNS-Based and Kubernetes Service Discovery

L

Labels
Labels are key-value pairs you attach to Kubernetes resources like Pods.
Lesson 1445 — Labels, Selectors, and Annotations
Lack of Test Coverage
The defining trait. Without tests, you can't verify changes didn't break something unexpected.
Lesson 1749 — Defining Legacy Code
latency
Think of a coffee shop: latency is how long one customer waits for their drink.
Lesson 1188 — Latency vs Throughput Trade-offs
Layered System Architecture
In REST, Layered System Architecture means you can add intermediate servers between the client and the origin server without either side knowing or caring.
Lesson 763 — Layered System Architecture
Lazy Loading
Cache-Aside (also called Lazy Loading) is a caching strategy where your application code manages the cache explicitly.
Lesson 966 — Cache-Aside (Lazy Loading)
Learning Through Building
Here's the paradox: you can't fully understand the problem until you start solving it. Stakeholders see a working prototype and realize, "Actually, that's not quite what we meant." Users interact with the first version and discover workflows nobody anticipated. Building software is a discovery process, and discoveries mean course corrections.
Lesson 160 — Why Requirements Change
Learning-Focused Feedback
Frame comments as learning opportunities. Instead of "This is wrong," try "Consider extracting this logic into a separate function for testability—here's why..." This shifts the tone from criticism to shared problem-solving.
Lesson 1617 — Creating a Constructive Review Environment
Length over complexity
A 16-character passphrase like correct-horse-battery-staple is exponentially stronger than P@ssw0rd! and easier to remember.
Lesson 1004 — Password Strength Requirements and Policies
Less code
You don't write custom shrinking functions—the generation strategy is the shrinking strategy
Lesson 619 — Integrated Shrinking
Level A
The minimum level of accessibility. Addresses fundamental barriers that would completely block some users from accessing content (e.g., providing text alternatives for images, ensuring keyboard navigation).
Lesson 1928 — WCAG Guidelines and Compliance Standards
Level AA
The recommended target for most organizations. Covers a broader range of accessibility barriers and is often the legal standard (e.g., minimum color contrast ratios, resizable text, consistent navigation).
Lesson 1928 — WCAG Guidelines and Compliance Standards
Level AAA
The highest level, though not always achievable for all content. Includes the most stringent requirements (e.g., sign language interpretation for videos, enhanced contrast ratios).
Lesson 1928 — WCAG Guidelines and Compliance Standards
LICENSE
The legal foundation you've chosen
Lesson 1882 — Starting an Open Source Project
Lightweight tags
Lightweight tags are simple pointers to a commit—just a name.
Lesson 1556 — Version Tagging in Git
limit
Your request is the minimum room size you need (the scheduler won't place you somewhere smaller), and your limit is the maximum space you can occupy without disturbing other guests.
Lesson 1451 — Resource Requests and Limits
Limit charts per dashboard
5–10 is often enough. Too many splits attention.
Lesson 1144 — Dashboard Design Principles
Live validation
The interface checks inputs against your schemas before sending requests
Lesson 844 — Interactive API Documentation
Living documentation
The schema is the documentation—always accurate, never stale
Lesson 841 — Benefits of Schema-First Development
Load balancing
Load balancing is the practice of distributing incoming network requests across multiple servers (often called a "server pool" or "backend servers") so that no single server bears too much burden.
Lesson 1388 — What is Load Balancing?
lock file
A lock file is an automatically generated file that records the exact version of every dependency (direct and transitive) that was installed at a specific moment.
Lesson 671 — Lock Files and Reproducibility
Lock granularity
Lock granularity refers to the size of the resource being locked—from an entire table down to individual rows or even smaller units.
Lesson 916 — Row-Level vs Table-Level Locking
Logs
Logs are discrete event records with detailed context.
Lesson 1136 — Metrics vs Logs vs Traces
Long Method
A Long Method is a code smell where a single method or function becomes bloated with too many lines of code and too many responsibilities.
Lesson 336 — Bloaters: Long Method
Low coupling
Low coupling means your modules depend on each other as little as possible.
Lesson 182 — The Relationship Between Coupling and Cohesion
Lower memory usage
Smaller indexes are easier to cache in memory
Lesson 876 — Partial and Filtered Indexes

M

magic link
A magic link is a unique, time-limited URL sent to your email.
Lesson 997 — Passwordless Authentication Methods
maintenance
The SDLC acknowledges that software isn't "done" after the first release—maintenance is ongoing, which aligns with what we learned about how most engineering time goes toward keeping systems running and evolving.
Lesson 9 — What is the Software Development Lifecycle (SDLC)?
Maintenance burden
Complex solutions require more documentation, more context to understand, and more careful changes. A simple three-line function is far easier to debug than a chain of decorators, factories, and abstract base classes—unless that complexity genuinely solves a real problem.
Lesson 1825 — Simplicity Over Complexity
Make
Make is the grandfather of build tools, dating back to Unix systems.
Lesson 660 — Common Build Tools Overview
Making trade-offs
choosing between competing needs when resources are limited
Lesson 21 — The Product Owner and Business Stakeholders
Managed services
Managed services are like the restaurant: the cloud provider handles the infrastructure, maintenance, patching, scaling, and operations of a service (like a database or message queue), while you simply use it.
Lesson 1511 — What Are Managed Services
Managing contract changes
Managing contract changes means deciding how to signal and implement changes.
Lesson 552 — Contract Versioning and Evolution
Manual instrumentation
Manual instrumentation means you explicitly add code to create spans around important business logic or custom operations.
Lesson 1149 — Instrumenting Code for Tracing
Masked variables
The platform stores secrets encrypted and injects them as environment variables at runtime, automatically hiding their values in logs (showing * instead)
Lesson 747 — Secrets in CI/CD Pipelines
Materialized Views
Materialized Views are precomputed query results stored as physical tables.
Lesson 866 — Denormalization Patterns
merge strategy
A merge strategy is the algorithm Git uses to combine changes from different branches.
Lesson 64 — Merge Strategies and Options
message broker
A message broker is infrastructure that sits between services, managing message queues and routing.
Lesson 1357 — Message Brokers vs Event Buses: Core Concepts
Message queues
Message queues are the infrastructure that makes this possible.
Lesson 1316 — Message Queues for Async Communication
Metrics
Metrics are numerical measurements aggregated over time.
Lesson 1136 — Metrics vs Logs vs Traces
microservices architecture
A microservices architecture is like a neighborhood of separate houses (services).
Lesson 1295 — Monolith vs Microservices
Migration paths
Tell users exactly how to upgrade. "Replace oldFunction() with newFunction(param)" is far better than "this is going away."
Lesson 676 — Deprecation and Version Lifecycle
Migration script quality
Rollback scripts are rarely tested as thoroughly as forward migrations. They're written "just in case" but seldom executed until the worst moment—when you're already in crisis mode.
Lesson 889 — Forward-Only Migration Philosophy
Milestones
Milestones are significant points in your project timeline that mark the completion of major phases or achievements.
Lesson 1659 — Identifying Milestones and Deliverables
MIME sniffing
This behavior is called MIME sniffing or content sniffing.
Lesson 1074 — X-Content-Type-Options and MIME Sniffing
Minimal input
The most basic valid input (empty collection, zero, single item)
Lesson 497 — Starting with the Simplest Test
Misleading names
The name suggests one thing but does another
Lesson 348 — Rename Method and Rename Variable
Missing Encryption in Transit
Sending data over HTTP instead of HTTPS means attackers can intercept it (man-in-the-middle attacks).
Lesson 1043 — A02: Cryptographic Failures
Mistakes have smaller impact
A developer with read-only database access can't accidentally DROP TABLE in production
Lesson 1033 — Principle of Least Privilege
Mocking frameworks
Mocking frameworks are specialized libraries that let you create test doubles on-the-fly using a simple API, rather than writing full classes.
Lesson 471 — Test Double Libraries and Frameworks
Mocks
Mocks are your choice when the interaction itself is what you're testing—when calling the right method with the right parameters is the behavior.
Lesson 472 — When to Use Each Type of Test Double
modular monolith
A modular monolith is a single deployable application that's internally organized into well-defined, loosely coupled modules with explicit boundaries and strong encapsulation.
Lesson 1288 — What is a Modular Monolith
module
A module is a distinct unit of deployment—a piece of software that can be built, packaged, and released independently.
Lesson 522 — What Are Module Boundaries
Molecule
Molecule is specifically designed for testing Ansible roles.
Lesson 1494 — Testing Configuration Code
Monolithic Applications
Within a single codebase, compile-time type checking and standard integration tests are usually sufficient. The overhead of contract tooling outweighs benefits.
Lesson 553 — When to Use Contract Tests
monolithic architecture
A monolithic architecture is like living in a single house where all rooms are connected through shared hallways and infrastructure.
Lesson 1295 — Monolith vs Microservices
More than ~400 lines changed
This is a rough guideline, not a hard rule, but beyond this point reviews become significantly harder.
Lesson 107 — Knowing When to Split a Pull Request
MoSCoW Method
The MoSCoW Method is a prioritization technique that sorts requirements into four categories based on necessity.
Lesson 153 — MoSCoW Method
Move Field
Move Method and Move Field are refactorings that relocate these misplaced elements to where they naturally fit.
Lesson 349 — Move Method and Move Field
Mutations
Mutations are how you write data—creating new records, updating existing ones, or deleting them.
Lesson 808 — Mutations: Writing Data in GraphQL

N

Name encodings
Name encodings are systems where you add prefixes or suffixes to variable names to indicate their type, scope, or other metadata.
Lesson 371 — Avoiding Encodings and Hungarian Notation
Network use clause
The AGPL v3 variant closes the SaaS loophole
Lesson 1866 — The GNU GPL Family
Networks
Networks are unreliable and unpredictable
Lesson 516 — External Dependencies and Infrastructure
Nightly builds
Run the full E2E suite when time constraints are relaxed
Lesson 561 — E2E Test Execution Strategy
No single source of truth
The same conceptual value might be written slightly differently in different places
Lesson 352 — Replace Magic Numbers with Constants
non-deterministic builds
This is called non-deterministic builds—the same inputs produce different outputs depending on when or where you build.
Lesson 671 — Lock Files and Reproducibility
non-repeatable reads
These are called non-repeatable reads, and Read Committed allows them.
Lesson 906 — Read Committed Isolation
Novel or surprising failures
New failure modes are learning opportunities, regardless of customer impact
Lesson 1181 — When to Conduct a Postmortem

O

Object Mother
The Object Mother is a pattern where you create a dedicated class (or set of classes) containing factory methods that build common test objects with reasonable default values.
Lesson 451 — Object Mother Pattern
Object Pool
An Object Pool is related but distinct: instead of cloning prototypes, you recycle actual object instances.
Lesson 249 — Prototype Registry and Object Pools
Observability
Observability means building systems that expose their internal state and behavior so you can understand what's happening in production without guessing.
Lesson 1244 — Testability and Observability
Octopus
Octopus is used when merging three or more branches simultaneously.
Lesson 64 — Merge Strategies and Options
on-call rotation
An on-call rotation is a schedule that determines which engineer is responsible for responding to alerts and incidents during specific time periods.
Lesson 1163 — The On-Call Rotation
One reason to change
One reason to change means one source of requirements.
Lesson 194 — What is the Single Responsibility Principle
Openness
Teams and stakeholders are open about work and challenges
Lesson 1581 — Scrum Framework Overview
Operational Burden
Managed services handle undifferentiated heavy lifting: backups, patching, scaling, high availability. Self-hosting means your team owns these responsibilities 24/7. Think of it like renting vs. buying a house—one includes maintenance, the other puts you on-call.
Lesson 1518 — Evaluating Managed Service Trade-offs
Operations naturally belong in the classes
if drawing a shape is its primary purpose, shape.draw() is clearer than DrawVisitor
Lesson 320 — When Visitor Adds vs Removes Flexibility
Opportunistic refactoring
Opportunistic refactoring means you clean up code while doing feature work—you're adding a function and notice messy code nearby, so you tidy it up before continuing.
Lesson 363 — Opportunistic vs Planned Refactoring
Opportunity cost
Opportunity cost is what you sacrifice when choosing one option over another.
Lesson 34 — The Cost of Delay and Opportunity Cost
Optimization per service
A recommendation engine might benefit from Python's data science libraries, while a payment processor needs Java's mature financial libraries and strict typing.
Lesson 1335 — Technology Heterogeneity and Experimentation
OPTIONS
While GET, POST, PUT, and DELETE manipulate resource data, HEAD and OPTIONS are special HTTP verbs designed purely for gathering information about resources—without modifying them or even retrieving their full content.
Lesson 767 — HEAD and OPTIONS: Metadata Operations
orchestrator
An orchestrator is a dedicated service that manages the entire saga workflow.
Lesson 1370 — Saga Execution Coordinators
Order of operations matters
A notification was sent (behavior) after validation succeeded (state)
Lesson 486 — Combining State and Behavior Verification
Organizational accountability
Organizational accountability means companies face:
Lesson 1923 — Professional Liability and Accountability
OWASP Top 10
The OWASP Top 10 is a regularly updated list (roughly every 3-4 years) that ranks the most critical security risks facing web applications.
Lesson 1041 — Introduction to the OWASP Top 10

P

Pa11y
Pa11y is a command-line tool that can test pages in isolation or as part of your CI/CD pipeline, providing detailed reports of accessibility issues.
Lesson 582 — Automated Accessibility Testing
Pact
Pact is the most widely-adopted framework.
Lesson 551 — Contract Testing Tools and Frameworks
Parallel Change
The Expand-Contract Pattern (also called Parallel Change) gives you a safe, gradual path forward.
Lesson 892 — The Expand-Contract Pattern
Parallelization
Parallelization means identifying which stages are independent and configuring your pipeline to execute them simultaneously.
Lesson 706 — Parallelization and Pipeline Efficiency
partial mocking
This is called partial mocking or spying.
Lesson 479 — Partial Mocking and Spying on Real Objects
Partitioning by entity or tenant
Partitioning by entity or tenant means organizing your data so that all records related to a specific entity (like a user, customer, or organization) live together in the same partition.
Lesson 1399 — Partitioning by Entity or Tenant
pass-through layers
These are called pass-through layers or thin layers, and they're a sign of architectural over-engineering.
Lesson 1261 — When Layers Become Too Thin
Passkeys
Passkeys are the user-facing implementation—cryptographic key pairs stored on your device.
Lesson 997 — Passwordless Authentication Methods
Patent Trolls
These are entities (often called "non-practicing entities") that acquire patents solely to extract licensing fees or lawsuit settlements. They don't build products—they monetize legal threats. Defending against them is expensive, even when you'd likely win.
Lesson 1888 — Patent Risks in Software Development
paths
The heart of the document. Each path (like /users or /products/{id}) represents an API endpoint. Under each path, you define operations (GET, POST, PUT, DELETE) that specify what actions are possible.
Lesson 838 — Anatomy of an OpenAPI Document
Per-test fixtures
Per-test fixtures are created fresh before each test and torn down after.
Lesson 542 — Shared vs Per-Test Fixtures
Perceived reduced output
Perceived reduced output is the biggest concern.
Lesson 1626 — Benefits and Trade-offs of Pair Programming
Performance
No network calls; data is local
Lesson 1309 — Data Duplication vs Data Coupling Trade-offs
Performance problems
Performance problems are debuggers' Achilles heel.
Lesson 1735 — Debugger Limitations and When to Use Alternative Tools
Performance regression
Performance regression means your system got slower, uses more memory, or handles fewer requests after a code change.
Lesson 1211 — Baseline Metrics and Regression Detection
Performance requirements outweigh storage costs
If milliseconds matter and disk space is cheap
Lesson 865 — Strategic Denormalization
Periodic scanning
Periodic scanning is the most common approach.
Lesson 1492 — Configuration Drift Detection
Persisted to disk
Messages are written to disk storage before acknowledging receipt. The broker can recover messages after a restart by reading from disk. Like writing in a notebook—slower, but permanent.
Lesson 1360 — Message Durability and Persistence
persona
A persona is a specific type of user with particular characteristics and needs.
Lesson 146 — User Story Components: Personas and Goals
Personal accountability
Personal accountability means you can face:
Lesson 1923 — Professional Liability and Accountability
Personal data
Personal data is any information that can identify a living individual, directly or indirectly.
Lesson 1900 — Personal Data and Sensitive Information
Phantom Reads
Phantom Reads are when a transaction executes the same query twice and gets different sets of rows because another transaction inserted or deleted rows that match the query.
Lesson 904 — What Isolation Levels Protect Against
Pinning
Pinning means specifying one exact version.
Lesson 673 — Pinning vs Flexible Versioning
Pipeline as Code
Pipeline as Code means writing your entire deployment pipeline—all its stages, tests, gates, and deployment steps—in text-based configuration files that live in your repository alongside your application code.
Lesson 708 — Pipeline as Code
Planned refactoring
Planned refactoring means you schedule dedicated time specifically to improve code structure, often for larger improvements that can't be done in small increments.
Lesson 363 — Opportunistic vs Planned Refactoring
playbooks
Runbooks and playbooks are pre-written, step-by-step guides that document how to handle specific incidents or operational tasks.
Lesson 1168 — Runbooks and PlaybooksLesson 1490 — Ansible Fundamentals
plugin architecture
A plugin architecture is a design pattern where your core system defines these extension points, and separate modules (plugins) provide implementations that hook into them.
Lesson 192 — Plugin Architectures and Extension Points
pod
A pod is Kubernetes' fundamental building block—the smallest unit you can create, deploy, and manage.
Lesson 1444 — Pods: The Atomic Unit of DeploymentLesson 1454 — Pods: The Basic Unit of Deployment
Pointer Chasing
Following references through layers (Facade → Subsystem A → Component X) means more memory accesses, which can hurt CPU cache performance.
Lesson 282 — Performance Overhead of Structural Patterns
poison messages
These are called poison messages—they're toxic to your system and can clog up your message queue if not handled properly.
Lesson 1363 — Dead Letter Queues and Error Handling
policies
In Kanban (and other Agile frameworks), policies are explicit, written rules that define how work items move through your workflow.
Lesson 1598 — Policies and Classes of Service
port
A port is an interface that defines how your core application interacts with the outside world.
Lesson 1264 — The Ports and Adapters Pattern
postcondition
A postcondition is a guarantee a method makes about what will be true after it executes.
Lesson 211 — LSP Violations: Weakening Postconditions
Postconditions
Postconditions are what must be true after a method completes.
Lesson 209 — Behavioral Subtyping and Contracts
Pre-commit hooks
Pre-commit hooks are the most common type.
Lesson 393 — Pre-commit Hooks and Git Hooks
pre-population
Cache warming (also called pre-population) means deliberately loading frequently accessed data into your cache before users request it.
Lesson 970 — Cache Warming and Pre-population
Preconditions
Preconditions are what must be true before a method runs.
Lesson 209 — Behavioral Subtyping and Contracts
Predicate pushdown
Predicate pushdown is the database optimizer's technique of applying these filters as early as possible in the query execution process—ideally before joining tables or scanning large datasets.
Lesson 881 — Filtering and Predicate Pushdown
Premature abstraction
Premature abstraction means introducing interfaces, inheritance hierarchies, or plugin systems before you have concrete evidence they're needed.
Lesson 207 — Balancing OCP with Simplicity
prepared statements
Parameterized queries (also called prepared statements) treat SQL code and user data as fundamentally separate things.
Lesson 1055 — Preventing SQL Injection with Parameterized Queries
Preserved knowledge
The team understands the business logic embedded in the code. Rewriting risks losing this knowledge.
Lesson 1765 — The Economics of Legacy Refactoring
Prettier
Prettier is one of the most popular code formatters, especially for JavaScript, TypeScript, CSS, and many other languages.
Lesson 392 — Code Formatters and Prettier
Prevent dead code elimination
The compiler will remove calculations whose results aren't used. Always "use" benchmark results—print them, return them, or pass them to functions that prevent optimization. Many benchmarking frameworks provide special functions to mark values as "used" without adding overhead.
Lesson 1200 — Writing Effective Benchmarks
Prevent production vulnerabilities
Issues are caught before merging, not after deployment.
Lesson 625 — Integrating Fuzzing into CI/CD
Primary Ports
Primary Ports (driving ports) are entry points where external actors initiate requests into your application.
Lesson 1266 — Primary and Secondary Ports
Prior art
Prior art is any publicly available evidence that your invention already existed before your patent filing date.
Lesson 1887 — The Patent Process and Prior Art
Privacy by Default
Privacy by Default means users get maximum privacy protection out of the box:
Lesson 1905 — Privacy by Design and Default
Privacy by Design
Privacy by Design means considering privacy at every stage:
Lesson 1905 — Privacy by Design and Default
Privilege escalation
Privilege escalation is the nightmare scenario.
Lesson 1031 — Choosing and Evolving Authorization Models
Process
Process means following systematic steps that keep work organized and verifiable:
Lesson 6 — Process and Discipline
Producers
Producers are components that detect something noteworthy has happened and emit an event to announce it.
Lesson 1340 — Event Producers and Consumers
Product Backlog
The Product Backlog is an ordered, living list of everything that might be needed in the product.
Lesson 1585 — The Product Backlog
production
Profiling in production is like checking vital signs on a patient: you need accurate data from real conditions, but you must minimize disruption and overhead.
Lesson 1199 — Profiling in Production vs Development
Production traffic analysis
Production traffic analysis means systematically examining metrics from your live system to understand actual usage patterns and plan accordingly.
Lesson 1218 — Production Traffic Analysis for Planning
professional code of ethics
A professional code of ethics is a formal document that outlines the moral principles, values, and standards of conduct expected from practitioners in a field.
Lesson 1892 — What Are Professional Codes of Ethics
Project Description
A clear 1-2 sentence summary of what the software does and who it's for. Don't assume readers understand your context—they may have just discovered your project through a search.
Lesson 1683 — README Files
Projection-Join Normal Form
Fifth Normal Form (5NF), also called Projection-Join Normal Form, handles join dependencies where information can be reconstructed losslessly by joining three or more tables, but combining them creates redundancy.
Lesson 863 — Higher Normal Forms (4NF, 5NF)
promotion packet
Your promotion packet is a structured document that proves you're already performing at the staff level.
Lesson 1823 — The Staff Engineer Promotion Path
Proposed
The decision is under discussion, not yet finalized
Lesson 1703 — ADR Status and Lifecycle
Protects invariants
Rules are enforced in one place
Lesson 171 — Encapsulation and Data Hiding
Prototype Registry
A Prototype Registry is a centralized collection of pre-made prototype objects that you can clone whenever you need similar instances.
Lesson 249 — Prototype Registry and Object Pools
providers
In Terraform, providers are plugins that enable communication with specific platforms or services (AWS, Azure, GCP, Kubernetes, Docker, etc.).
Lesson 1482 — Terraform Resources and Providers
Pruning
Pruning is the act of removing dependencies identified as unused during auditing.
Lesson 681 — Dependency Pruning and Auditing
Public API
The only way other modules interact with yours—typically services, commands, or queries
Lesson 1290 — Defining Module Boundaries
Pull request triggers
Build runs when a PR is opened or updated
Lesson 639 — Build Triggers and Webhooks
Pure interfaces
Pure interfaces are perfect for ISP because they only declare methods—no implementation.
Lesson 219 — ISP and Language Features: Abstract Classes vs Interfaces

Q

Quality Attribute Scenario
A Quality Attribute Scenario is a structured, three-part statement that makes quality requirements concrete:
Lesson 1248 — Quality Attribute Scenarios
quality gate
A quality gate is a set of automated checks that run in your CI (Continuous Integration) pipeline and must pass before code can be merged into your main branch.
Lesson 394 — CI-Based Quality Gates
query
In GraphQL, a query is how clients read data from the server.
Lesson 807 — Queries: Reading Data in GraphQL
Query parameters
Query parameters are simple but clutter URLs.
Lesson 848 — API Versioning Strategies
query side
In CQRS, the query side is entirely separate from the command side.
Lesson 1352 — Query Side and Projections
query whitelisting
Taking persisted queries further, query whitelisting means the server only accepts pre-registered queries—rejecting any arbitrary query text.
Lesson 821 — Persisted Queries and Query Whitelisting
Quick Start Guide
A minimal working example showing how to use the core functionality. Think "hello world" for your project—the fastest path to seeing value.
Lesson 1683 — README Files

R

Randomizing test execution order
Randomizing test execution order means shuffling tests so they run in a different sequence each time.
Lesson 460 — Randomizing Test Execution Order
Rarely touched code
If nobody needs to modify it, the refactoring ROI is near zero.
Lesson 1765 — The Economics of Legacy Refactoring
Rate-of-change
sudden drops (100→10 req/sec) matter even if both are "low"
Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
Readability matters
a class named AlwaysSuccessfulPaymentGateway is clearer than mock configuration
Lesson 478 — Mock Frameworks and Hand-Rolled Doubles
Real-time
Invalidation happens immediately when events are processed
Lesson 980 — Event-Driven Invalidation
Rebalancing
Rebalancing is the process of redistributing data across the cluster when the number of partitions or nodes changes.
Lesson 1400 — Rebalancing Partitions
Receiver
Think of it like a restaurant: the Command Interface is the standard order slip format, Concrete Commands are specific orders (burger, salad), the Invoker is the waiter who submits orders, and the Receiver is the kitchen that cooks the food.
Lesson 291 — Implementing the Command Pattern
Recovery Point Objective
Recovery Point Objective is the maximum amount of data loss you can tolerate, measured in time.
Lesson 724 — Recovery Point and Time Objectives
Recovery Time Objective
Recovery Time Objective is the maximum acceptable downtime—how long your system can be unavailable before causing unacceptable business impact.
Lesson 724 — Recovery Point and Time Objectives
Recursive
Recursive is Git's default strategy for merging two branches.
Lesson 64 — Merge Strategies and Options
Redeployment-Required Configuration
Redeployment-Required Configuration means configuration is loaded once at startup.
Lesson 732 — Configuration Changes Without Redeployment
Reduced risk
Changes are localized, so bugs are less likely to spread unexpectedly
Lesson 177 — Understanding Coupling: How Components Depend on Each Other
Redundancy
The same information appears in multiple places. Imagine storing a customer's address with every order they place—that's wasteful and error-prone.
Lesson 860 — What is Normalization?
Refactoring
Refactoring is the process of restructuring existing code to improve its internal design, readability, and maintainability without changing what the code actually does from the outside.
Lesson 327 — What is Refactoring?Lesson 334 — Refactoring vs RewritingLesson 1757 — When to Rewrite vs Refactor
Reflected XSS
Script comes from the URL or request and is immediately echoed back
Lesson 1062 — Cross-Site Scripting (XSS) Overview
reflog
The reflog (reference log) is Git's secret insurance policy.
Lesson 70 — The Reflog: Git's Safety Net
refresh token
A refresh token is a long-lived credential issued alongside your short-lived access token.
Lesson 1013 — Token Refresh and Rotation
Refresh tokens
Refresh tokens are long-lived credentials used solely to obtain new access tokens when the old ones expire—like a special ID card you show at the security desk to get a new visitor badge.
Lesson 1021 — Access Tokens, Refresh Tokens, and Token Lifetime
Regression tests
Regression tests are tests that verify previously fixed bugs stay fixed and that existing functionality continues to work after new changes.
Lesson 419 — Regression Tests: Preventing Old Bugs
rehydration
This process is called rehydration or reconstitution.
Lesson 1349 — Rebuilding State from Events
Release notes
Release notes are user-facing summaries accompanying specific releases, often extracted from or based on the changelog but written with your audience in mind.
Lesson 1687 — Changelog and Release Notes
Release windows
Release windows are pre-approved time slots when deployments are permitted, while blackout periods are times when releases are prohibited or severely restricted.
Lesson 1548 — Release Windows and Blackout Periods
reliability
If a server crashes, clients just retry with another server; nothing is lost
Lesson 131 — Reliability and Availability RequirementsLesson 757 — Statelessness in REST
Reliability and Reproducibility
Reliability and Reproducibility are the crown jewels.
Lesson 1478 — Benefits and Challenges of Immutability
Reliable but less available
The machine is offline for maintenance regularly (lower availability), but when it works, it always dispenses exactly what you paid for (high reliability).
Lesson 1241 — Availability and Reliability
remote proxy
A remote proxy represents an object in a different address space—perhaps on another server or process.
Lesson 278 — Types of Proxies: Virtual, Protection, and Remote
remote repository
A remote repository is simply a copy of your Git repository that lives somewhere else, typically on a server or cloud platform like GitHub, GitLab, or Bitbucket.
Lesson 73 — What Are Remote Repositories
Removes need for comments
The name itself explains the purpose
Lesson 365 — Intention-Revealing Names
Removing obsolete items
Delete or archive stories that are no longer relevant
Lesson 157 — Backlog Management
Rename Method
Rename Method means changing a method's name to better express what it does.
Lesson 348 — Rename Method and Rename Variable
Replace Global State
Globals and singletons (like Database.getInstance()) are testing nightmares. Wrap them in a parameter or instance variable you control.
Lesson 1754 — Breaking Dependencies to Enable Testing
Replace Temp with Query
Replace Temp with Query means taking that calculation, moving it into its own method (a "query"), and calling that method instead of using the temp variable.
Lesson 357 — Replace Temp with Query
representation
While the resource itself is the underlying concept (like "a user" or "an order"), the representation is how you package that data—typically as JSON.
Lesson 779 — Designing Resource Representations
Reproducibility
Reproducibility means you can make the bug happen on demand, reliably, following specific steps.
Lesson 1720 — The Importance of Reproducibility
reproducible build
A reproducible build means that given the same source code and build environment, you should get byte-for-byte identical output every time.
Lesson 687 — Sources of Non-Determinism
request
Your request is the minimum room size you need (the scheduler won't place you somewhere smaller), and your limit is the maximum space you can occupy without disturbing other guests.
Lesson 1451 — Resource Requests and Limits
Request and response validation
Request and response validation means using these schemas to automatically verify that actual HTTP traffic conforms to your specification.
Lesson 843 — Request and Response Validation
requestBody
The structure of data sent to the API (for POST/PUT)
Lesson 838 — Anatomy of an OpenAPI Document
Resilience patterns
Resilience patterns are battle-tested architectural strategies that help systems continue functioning (even in degraded modes) when parts fail.
Lesson 1093 — Introduction to Resilience Patterns
Resource constraints
Locust and k6 are lighter than JMeter
Lesson 1213 — Load Testing Tools and Frameworks
Resources
Resources are the actual infrastructure components you want to create or manage—virtual machines, databases, networks, storage buckets, or anything else your platform offers.
Lesson 1482 — Terraform Resources and ProvidersLesson 1484 — Terraform Modules and Reusability
Response urgency
P0 means wake everyone up at 3 AM. P3 can wait until Monday morning.
Lesson 1164 — Incident Severity Levels
Responsive design
Responsive design means your layout, navigation, and interactive elements adjust based on available screen space.
Lesson 568 — Mobile and Responsive Testing
Return consistent metadata
Your response should include total count (after filtering), current page, and links to navigate—regardless of which combination of features is used.
Lesson 789 — Combining Pagination, Filtering, and Sorting
revert-first strategy
The revert-first strategy means your default action is to revert the breaking commit immediately, restoring the build to green, then fix the problem properly in a new commit.
Lesson 655 — The Revert-First Strategy
Rewriting
Rewriting means building a new system from scratch to replace the old one—you're demolishing the house and constructing a new one, hoping everyone can move seamlessly.
Lesson 334 — Refactoring vs RewritingLesson 1757 — When to Rewrite vs Refactor
Ripple Effects
A bug fix in one area creates bugs elsewhere. Teams become afraid to refactor or improve code because the blast radius is unpredictable. This leads to technical debt accumulation as developers work around problems instead of fixing them.
Lesson 179 — The Cost of Tight Coupling
Risk
High-churn code areas or complex business logic deserve more tests. Stable utility functions might need less. Focus testing where bugs are most likely or most damaging.
Lesson 427 — Finding the Testing Sweet Spot
Risk-based testing
Risk-based testing means directing your testing energy toward the code that poses the highest risk if it fails.
Lesson 402 — What to Test: Risk-Based Testing
rituals
Agile ceremonies (also called rituals or events) are recurring, time-boxed team meetings designed to create rhythm and transparency in Agile workflows.
Lesson 1600 — What Are Agile Ceremonies?
Rollback
Rollback is your safety net—the ability to quickly return to the last known-good state.
Lesson 719 — Deployment Risk and the Need for Rollback
Root cause
A specific code path that fails to release memory after processing certain requests
Lesson 1742 — Learning from Production IncidentsLesson 1746 — Contributing Factors vs. Root Causes
Root causes
Root causes are the fundamental issues that, if addressed, would prevent the problem from happening again.
Lesson 1746 — Contributing Factors vs. Root Causes
runc
The most widely-used low-level runtime, implements the OCI (Open Container Initiative) specification
Lesson 1426 — The Container Runtime

S

Safer refactoring
Small changes are easier to undo or adjust
Lesson 493 — Taking Small Steps in TDD
Safety thresholds
some values are always dangerous regardless of patterns
Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
saga
A saga is a sequence of local transactions where each service performs its own database transaction and publishes an event or message to trigger the next step.
Lesson 1366 — What is the Saga Pattern
salt
A salt is a unique, random value generated for each user that gets combined with their password before hashing.
Lesson 1001 — Salt: Preventing Rainbow Table Attacks
Sanity tests
Sanity tests are similar but slightly different—they verify that a specific area or recent change makes logical sense before proceeding.
Lesson 423 — Smoke and Sanity Tests: Quick Health Checks
schema
In GraphQL, the schema is the single source of truth—it's the formal contract that describes exactly what data clients can query and what operations they can perform.
Lesson 806 — GraphQL Schema and Type SystemLesson 1364 — Message Schemas and Evolution
schema registry
A schema registry is a centralized service that stores, versions, and validates schemas.
Lesson 1364 — Message Schemas and Evolution
Schema-first design
Schema-first design means you start by writing your OpenAPI document (or similar contract) before touching any implementation code.
Lesson 840 — Schema-First vs Code-First Design
Screen Readers
Blind and low-vision users navigate via text-to-speech software. Every interactive element needs semantic HTML and meaningful labels. An icon button without alt text is invisible to screen readers—like a door with no handle. Images, forms, and dynamic content all need textual descriptions that convey purpose, not just presence.
Lesson 1929 — Designing for Diverse Abilities
seam
A seam is a place in your code where you can alter behavior without editing the code at that location.
Lesson 1311 — Service Decomposition PatternsLesson 1753 — Finding Seams in Legacy CodeLesson 1769 — Seams and Dependency Breaking
Secondary Ports
Secondary Ports (driven ports) are exit points where your application initiates calls out to external systems.
Lesson 1266 — Primary and Secondary Ports
Secrets
While most configuration values (like server ports or feature flags) are safe to share openly, secrets are different.
Lesson 642 — Environment Variables and SecretsLesson 740 — What Are Secrets and Why They Matter
Security and Trust
Anyone can verify that your published binary actually came from the claimed source code. No hidden backdoors or malicious modifications can slip in undetected. This is critical for security-sensitive applications.
Lesson 691 — Benefits and Trade-offs
Security Breaches
Source code often gets shared widely—through version control systems, code reviews, shared repositories, or even accidentally public GitHub repositories. Once a secret is in your code history, it's there forever, even if you delete it later. Attackers actively scan public repositories for hardcoded credentials.
Lesson 741 — The Dangers of Hardcoding Secrets
Security by design
Security by design means building systems that remain secure even when attackers know exactly how they work—like using a high-quality lock that can't be picked even when the attacker understands its mechanism.
Lesson 1035 — Security by Design, Not Obscurity
seed
A seed is a number that initializes the random number generator.
Lesson 620 — Reproducing and Seeding
Seed data
Pre-populated rows inserted before tests run. You might create sample users, products, or orders that multiple tests can reference. This data represents the "baseline" state of your database.
Lesson 543 — Database Fixtures and Test Data
Self-hosted infrastructure
Self-hosted infrastructure is like having the chef: you control everything but must manage all the cooking, cleaning, and equipment maintenance yourself.
Lesson 1511 — What Are Managed Services
Sensitive information
Sensitive information is a subset of personal data that carries higher risk if exposed.
Lesson 1900 — Personal Data and Sensitive Information
Separation of Concerns
Separation of Concerns means organizing your software so that different parts handle different responsibilities, and each part focuses on one thing without overlapping with others.
Lesson 166 — Separation of Concerns
Server-side
You tell the host you need a table, and they escort you wherever they think is best. Simpler for you, but you depend on their judgment.
Lesson 1324 — Client-Side vs Server-Side Discovery
Server-Side Discovery
The client makes a request to a load balancer or API gateway at a well-known location. This intermediary queries the registry and routes the request to an appropriate service instance. The client remains unaware of individual instances.
Lesson 1324 — Client-Side vs Server-Side Discovery
Serverless computing
Serverless computing is a cloud execution model where you write and deploy code without provisioning, configuring, or managing servers.
Lesson 1519 — What is Serverless and Function as a Service
service mesh
A service mesh is a dedicated infrastructure layer that manages inter-service communication concerns outside your application code.
Lesson 1318 — Service Mesh and Communication Infrastructure
service registry
A service registry is the authoritative directory that tracks which service instances are currently running and where they're located.
Lesson 1325 — Service Registry Patterns
Session-per-request
Session-per-request is typical in web apps: one session for the entire HTTP request lifecycle.
Lesson 950 — Session and Transaction Management
Set meaningful thresholds
Color-code green/yellow/red zones so problems are obvious
Lesson 1144 — Dashboard Design Principles
sharding
Data partitioning (also called sharding) solves this by dividing your dataset across multiple databases or storage nodes.
Lesson 1396 — Why Partition Data?
Shared fixtures
Shared fixtures are set up once before all tests run and torn down once at the end.
Lesson 542 — Shared vs Per-Test Fixtures
shared lock
A shared lock is acquired when a transaction wants to read data.
Lesson 915 — Shared and Exclusive Locks
Shotgun Surgery
Shotgun Surgery is the opposite: one conceptual change requires modifying many unrelated classes.
Lesson 340 — Change Preventers: Divergent Change and Shotgun Surgery
Shrinking
Shrinking is the process where the framework automatically tries to find a smaller, simpler input that still causes the same failure.
Lesson 617 — Shrinking Fundamentals
Simple Factory Pattern
The Simple Factory Pattern is the most basic form of factory pattern.
Lesson 241 — Simple Factory Pattern
Simplified systems
Less data means simpler storage, processing, and maintenance
Lesson 1901 — Data Minimization Principle
Single logical purpose
Single logical purpose means one commit or pull request should do one thing: fix a bug, add a feature, refactor a function, or update documentation—not all four.
Lesson 100 — Writing Small, Focused Changes
Single point of failure
If that person is compromised, the entire system is at risk
Lesson 1037 — Separation of Duties
Single source of truth
Maintain one place where project status is always current
Lesson 25 — Communication Channels and Stakeholder Management
Skip persistence when
Messages are transient notifications or easily regenerated data (cache invalidations, metrics)
Lesson 1360 — Message Durability and Persistence
SMS-Based Codes
The server sends a temporary code via text message. While convenient, this is the weakest MFA method since SMS can be intercepted or SIM-swapped.
Lesson 994 — Multi-Factor Authentication (MFA)
snapshot
A snapshot is a stored copy of an aggregate's complete state at a specific point in time.
Lesson 1354 — Snapshots and Performance
snapshot testing
Approval testing (also called snapshot testing) works differently than assertion-based tests.
Lesson 1762 — Approval Testing for Complex Outputs
software entropy
Your code experiences the same phenomenon, called software entropy.
Lesson 41 — Code Evolution and Entropy
Some upfront thinking
Some upfront thinking is essential: You need to know your domain, identify key boundaries, and understand major components.
Lesson 512 — Emergent Design vs. Upfront Design
span
A span is one unit of work within that trace—a single operation like a database query, HTTP call, or function execution.
Lesson 1147 — Traces, Spans, and Context Propagation
spans
Distributed tracing follows a single request (called a trace) as it flows through your entire system, creating a timeline of connected events (called spans).
Lesson 1146 — What is Distributed Tracing
spatial decoupling
In Event-Driven Architecture, spatial decoupling means that event producers don't need to know who is listening or where those listeners are located.
Lesson 1342 — Spatial Decoupling
specific name and contact details
The specific name and contact details are extrinsic—unique to each individual card and provided at print time.
Lesson 275 — Intrinsic vs Extrinsic State in Flyweight
Spies
Spies are ideal when you care about both the return value and whether/how something was called.
Lesson 472 — When to Use Each Type of Test Double
spike
A spike is a time-boxed investigation task designed to answer a specific unknown.
Lesson 1663 — Identifying Unknowns and Spikes
spike solution
A Proof of Concept (PoC) or spike solution is a focused, time-limited technical investigation designed to answer a specific question or validate an approach.
Lesson 1844 — Proof of Concepts and Spike Solutions
Sprint
A Sprint is a time-boxed iteration—usually lasting two weeks (though one to four weeks is common)—during which the Development Team works to create a potentially releasable increment of the product.
Lesson 1586 — Sprints in Scrum
Sprint Retrospective
The Sprint Retrospective is a dedicated meeting held at the end of every sprint where the entire Scrum team examines how they worked together, not just what they delivered.
Lesson 1590 — Sprint Retrospective
Sprint Review
The Sprint Review is a collaborative ceremony held at the end of each Sprint where the Development Team demonstrates the working software they've completed to stakeholders, customers, and the Product Owner.
Lesson 1589 — Sprint Review
spy
A spy is a test double that wraps around a real object (or function), allowing it to execute normally while secretly recording every interaction.
Lesson 468 — Spies: Recording Interactions for Verification
SSL stripping
A man-in-the-middle attacker can intercept that initial HTTP request and keep the user on an insecure connection — a technique called SSL stripping.
Lesson 1071 — HTTP Strict Transport Security (HSTS)
stakeholder
A stakeholder is anyone affected by your software or who can affect its success.
Lesson 133 — Stakeholder Identification and Analysis
Stakeholder-driven prioritization
Stakeholder-driven prioritization means actively engaging those different voices, understanding their perspectives, and making deliberate trade-offs that the team can explain and defend.
Lesson 156 — Stakeholder-Driven Prioritization
stakeholders
In software engineering, stakeholders are all the people or groups who care about, influence, or are affected by your software project.
Lesson 19 — Who Are Stakeholders?
State management
State management is the system that tracks the real-world resources your IaC has created, so it can compare reality against your declarations.
Lesson 1469 — State Management in IaC
State Pattern
State Pattern is about managing object behavior that changes based on internal state.
Lesson 313 — Strategy vs State Pattern
State-specific logic
State-specific logic is complex and scattered
Lesson 311 — State Pattern vs Conditional Logic
statelessness
In REST, statelessness means the server doesn't remember anything about previous requests from a client.
Lesson 757 — Statelessness in REST
static factory method
A static factory method is simply a public static method that returns an instance of a class, instead of calling a constructor directly.
Lesson 240 — Static Factory Methods
Static thresholds
Static thresholds are fixed values that never change.
Lesson 1157 — Threshold Selection: Static vs. Dynamic Baselines
Statistics
Statistics are metadata about your data: how many rows, distribution of values, histogram of common values.
Lesson 877 — Index Maintenance and Statistics
Status badges
Status badges are visual indicators embedded in your README or project dashboard.
Lesson 643 — Build Notifications and Reporting
Step Out
Finish executing the current function and pause when returning to the caller. Use this when you've seen enough of the current function and want to return to the calling context. This is "go back up."
Lesson 1728 — Debugger Fundamentals: Breakpoints and Execution Control
Steps
The actual commands—install dependencies, run tests, build artifacts
Lesson 638 — Build Configuration Files
sticky sessions
Session affinity, often called sticky sessions, is when a load balancer consistently routes all requests from the same user to the same backend server.
Lesson 1392 — Session Affinity and Its Problems
StorageClass
A template defining how to dynamically provision storage (e.g., AWS EBS, Google Persistent Disk, NFS). When a PVC references a StorageClass, Kubernetes automatically creates a matching PV on-demand.
Lesson 1459 — Persistent Volumes and Claims
Stored XSS
Malicious script is saved in your database
Lesson 1062 — Cross-Site Scripting (XSS) Overview
Storing Sensitive Data in Plain Text
Transmitting passwords, credit cards, or personal information without encryption. We covered password hashing earlier—storing passwords as plain text is a classic cryptographic failure.
Lesson 1043 — A02: Cryptographic Failures
strangulation boundary
A strangulation boundary is the dividing line between old and new code where you'll intercept requests and route them to either the legacy system or your modern replacement.
Lesson 1775 — Identifying Strangulation Boundaries
Strategic denormalization
Strategic denormalization means deliberately adding redundancy or flattening data structures to speed up common read operations—while being fully aware of the trade-offs.
Lesson 865 — Strategic Denormalization
Strategy pattern
The Strategy pattern is a design pattern that encapsulates different algorithms or behaviors into separate classes, all implementing the same interface.
Lesson 205 — The Strategy Pattern and OCPLesson 313 — Strategy vs State Pattern
stub
A stub is a test double that provides hardcoded answers to method calls made during tests.
Lesson 466 — Stubs: Providing Canned Responses
Stubs
Stubs are further up because they only return pre-programmed responses without real logic.
Lesson 476 — The Test Double Pyramid
sunset date
A sunset date is the final day a version remains available.
Lesson 794 — Managing Multiple API Versions
Superseded
A newer ADR has replaced this one entirely
Lesson 1703 — ADR Status and Lifecycle
Support tiers
Clarify which versions get bug fixes, security patches, or new features. Users need to know if staying on an old version is risky.
Lesson 676 — Deprecation and Version Lifecycle
survey
A survey is a structured collection of questions distributed to many people simultaneously.
Lesson 139 — Questionnaires and Surveys
Swimlanes
Swimlanes are horizontal rows that divide the board by category.
Lesson 1593 — The Kanban Board
Synchronous replication
The leader waits for at least one follower to confirm it received the write before acknowledging success to the client. Guarantees consistency but adds latency.
Lesson 1402 — Leader-Follower Replication
System archaeology
System archaeology is similar: you dig through old code, manuals, specifications, and process documents to uncover what a system actually does and what requirements it must fulfill.
Lesson 137 — Document Analysis and System Archaeology
System integration
A function that's 10% faster in isolation might not matter if it consumes only 0.5% of your total runtime. Conversely, optimizing a microbenchmark-winning approach might worsen overall performance by increasing memory pressure or blocking other operations.
Lesson 1201 — Microbenchmarks and Their Limitations

T

Task-to-task dependencies
Task-to-task dependencies are the most common: "We can't start database migration testing until we finish writing the migration scripts."
Lesson 1666 — What Are Project Dependencies
Tasks
Tasks are individual units of work (install package, copy file, restart service).
Lesson 1490 — Ansible Fundamentals
Team bottlenecks
Multiple teams are blocked waiting to deploy shared code
Lesson 1330 — Microservices Are Not a Goal
Team Context
A junior team benefits from more comprehensive tests as guardrails. Experienced teams might confidently write fewer tests. Consider your team's speed, skill, and comfort level.
Lesson 427 — Finding the Testing Sweet Spot
tech lead
A tech lead is someone who simultaneously writes code and guides the technical direction of a team or project.
Lesson 1786 — What is a Tech Lead?
Tech Talks
Tech Talks are scheduled presentations where engineers share deep dives into technologies, architecture decisions, or lessons learned.
Lesson 1843 — Knowledge Sharing Mechanisms
Technical debt
Technical debt is a metaphor that compares software development shortcuts to financial debt.
Lesson 36 — What is Technical Debt
Technology obsolescence
The language, framework, or platform is unsupported or unhireable.
Lesson 1765 — The Economics of Legacy Refactoring
Test brittleness
If tests break whenever unrelated code changes, coupling is high
Lesson 183 — Measuring Coupling and Cohesion in Practice
test double
A test double is a stand-in replacement for a real dependency during testing.
Lesson 464 — What are Test Doubles and Why Use Them
test environment
A test environment is a complete, isolated copy of your production infrastructure—databases, services, APIs, and configurations—but separate and safe for testing.
Lesson 558 — Test Environments for E2E Testing
test fixture
A test fixture is the fixed state of objects, data, and environment that you set up before running a test.
Lesson 540 — What Are Test Fixtures
Test fixtures
Test fixtures are shared setup objects created once (often in setup methods) and reused across multiple tests.
Lesson 455 — Test Fixtures vs Builders
Test Kitchen
Test Kitchen is a framework that spins up temporary virtual machines or containers, applies your configuration code (Ansible, Chef, Puppet), and then runs verification tests against the configured system.
Lesson 1494 — Testing Configuration Code
Testability
Testability means designing software so it's easy to verify correctness through automated tests.
Lesson 1244 — Testability and Observability
Tested
The code has comprehensive test coverage—unit tests, integration tests, and any other relevant tests have passed. Edge cases are handled, and the behavior is verified.
Lesson 694 — Production-Ready Definition
Testing
A real database adapter vs. an in-memory test adapter
Lesson 1270 — Multiple Adapters for One Port
testing pyramid
The testing pyramid is a visual guide for balancing your testing strategy.
Lesson 407 — The Testing Pyramid Concept
testing trophy
The testing trophy is an alternative to the testing pyramid, proposed by Kent C.
Lesson 412 — The Testing Trophy Alternative
Tests that duplicate coverage
Tests that duplicate coverage are the most common offenders.
Lesson 429 — When to Skip or Delete Tests
Think of it like urban planning
A city planner doesn't just design roads for today's traffic—they consider population growth, economic trends, and quality of life goals. Similarly, you're architecting systems that must support future scale, new markets, and evolving customer needs.
Lesson 1821 — Technical Strategy and Vision
Think time
Think time is the pause between requests that simulates human behavior.
Lesson 1214 — Designing Realistic Load Tests
Throughput
Throughput is how many drinks the shop makes per hour.
Lesson 1188 — Latency vs Throughput Trade-offs
thundering herd
This is the cache stampede (also called thundering herd): when a popular cache entry expires, a stampede of requests rushes to rebuild it, overwhelming the backend.
Lesson 983 — Cache Stampede and Thundering Herd
Tight Coupling
If you need to create five other objects just to test one class, those dependencies are too tangled. The test's pain signals: "simplify these relationships."
Lesson 507 — TDD as a Design Tool
Time-critical opportunities
A competitor launches tomorrow, and you need a minimum viable response today
Lesson 42 — Balancing Debt and Delivery
Timeboxing
Accept data within a known time window. If TTL is 60 seconds, you know data is at most 60 seconds old.
Lesson 982 — Dealing with Stale Data
Token rotation
Token rotation means issuing a new refresh token every time one is used—the old refresh token becomes invalid.
Lesson 1013 — Token Refresh and Rotation
trace
Distributed tracing follows a single request (called a trace) as it flows through your entire system, creating a timeline of connected events (called spans).
Lesson 1146 — What is Distributed TracingLesson 1147 — Traces, Spans, and Context Propagation
trace ID
A trace ID is a globally unique identifier assigned when a request enters your system.
Lesson 1148 — Trace IDs and Correlation
tracking
This relationship is called tracking (or sometimes "upstream tracking").
Lesson 79 — Tracking Branches
trade secret
A trade secret is confidential business information that provides a competitive advantage and is actively protected from disclosure.
Lesson 1889 — Trade Secrets: Definition and Protection
Transparency
Everything needed to understand a request is visible in that request
Lesson 757 — Statelessness in REST
Treat each invocation independently
Design as if every call is the first call ever.
Lesson 1522 — Stateless Function Design
Triangulation
Triangulation is the technique of adding more test cases with different inputs until the hard-coded approach breaks, forcing you to generalize.
Lesson 494 — Triangulation: Adding Tests to Drive Generalization
Troubleshooting Tips
Address common pitfalls. "If you see error X, check that Y is configured."
Lesson 1681 — User Guides and Tutorials
Trunk-Based Development
Trunk-Based Development (TBD) is a branching strategy where everyone works on a single main branch—the "trunk." Instead of creating long-lived feature branches that exist for days or weeks, developers either commit directly to the trunk or create branches that last only a few hours before merging.
Lesson 83 — Trunk-Based DevelopmentLesson 646 — Working on the Trunk vs Feature Branches
trust boundary
A trust boundary is any point where data crosses from an untrusted source into your application's trusted zone.
Lesson 1039 — Trust Boundaries and Input Validation
Twelve-Factor App
The Twelve-Factor App is a methodology created by engineers at Heroku that defines best practices for building software-as-a-service applications.
Lesson 1503 — The Twelve-Factor App Methodology
Type Safety
Strong typing ensures field names don't become typos scattered across your codebase. Some libraries offer compile-time checks that "userId" is always a number, never a string.
Lesson 1133 — Structured Logging Libraries and APIs

U

Unclear Intent
The code works, but why it works or what business rules it implements may be mysterious. Comments are sparse or outdated.
Lesson 1749 — Defining Legacy Code
Unit tests
Unit tests are cheap—they run in milliseconds, test small pieces in isolation, and rarely break when you refactor unrelated code.
Lesson 407 — The Testing Pyramid ConceptLesson 409 — The Cost-Confidence Trade-off
Upfront design
Upfront design means planning your architecture, classes, and relationships before writing code.
Lesson 512 — Emergent Design vs. Upfront Design
upstream
The original repository you forked from (where you pull updates)
Lesson 81 — Working with Multiple Remotes
URI versioning
URI versioning is easiest for clients and testing.
Lesson 848 — API Versioning Strategies
Usability
Usability is how easily users can accomplish their goals with your system.
Lesson 1245 — Usability and Accessibility
user story
A user story is a short, simple description of a software feature written from the end-user's point of view.
Lesson 143 — What is a User Story?
Using data and evidence
Opinions are weak; data is strong. Show metrics, prototype results, or case studies that demonstrate your point.
Lesson 1794 — Influence Without Authority

V

Velocity
Velocity is empirical—what they actually deliver.
Lesson 1656 — Velocity and Capacity Planning
Vendoring
Vendoring means copying dependency source code directly into your project's repository.
Lesson 680 — Vendor Dependencies and Private Packages
Verbose error messages
Verbose error messages are surprisingly dangerous.
Lesson 1046 — A05: Security Misconfiguration
Version control
Every pipeline change is tracked in Git with commit messages explaining why
Lesson 43 — What is Version Control and Why Git?Lesson 708 — Pipeline as Code
version lifecycle
A version lifecycle describes the stages a version goes through: active development, maintenance mode, and eventual end-of-life (EOL).
Lesson 676 — Deprecation and Version Lifecycle
Vertical scaling
Vertical scaling is simpler initially—no changes to your application architecture needed, just more powerful hardware.
Lesson 1240 — Scalability: Horizontal and Vertical
Vertical slicing
Vertical slicing means decomposing work so each slice goes "vertically" through your entire application stack—from user interface through business logic to database and back—rather than working on one layer at a time ("horizontal slicing").
Lesson 1661 — Vertical Slicing
Visualization
Log management tools (like Elasticsearch, Splunk, or CloudWatch) can graph trends, build dashboards, and alert on thresholds—all because the data fields are predictable and machine-readable.
Lesson 1135 — Querying and Analyzing Structured Logs

W

Weak typing
Weak typing means errors surface at runtime
Lesson 1315 — gRPC for Service-to-Service Communication
WebAuthn
WebAuthn is a web standard that lets users authenticate using biometrics, security keys, or device credentials.
Lesson 997 — Passwordless Authentication Methods
webhook
A webhook is how your version control system (like GitHub or GitLab) notifies your CI server that something happened.
Lesson 639 — Build Triggers and Webhooks
Whether assertions check the right behavior
A test might execute code but only verify trivial or wrong conditions
Lesson 592 — Limitations of Coverage Metrics
Whistleblowing
Whistleblowing is the act of reporting illegal, unethical, or dangerous practices to external authorities or the public when internal channels fail or are unsafe.
Lesson 1921 — Whistleblowing and Legal Protections
Work Breakdown Structure
A Work Breakdown Structure is a hierarchical decomposition of your entire project into smaller, progressively more detailed components.
Lesson 1658 — Work Breakdown Structures (WBS)
Work Distribution
Multiple workers pull from the same queue, naturally load-balancing tasks across the pool. If one worker is busy, another picks up the next message.
Lesson 1359 — Message Queues and Point-to-Point Messaging
Working infrastructure
The surrounding systems, deployment pipelines, and integrations can remain intact.
Lesson 1765 — The Economics of Legacy Refactoring
Wrong guesses
Your prediction about future needs is often incorrect, making the work useless
Lesson 170 — You Aren't Gonna Need It (YAGNI)

Y

YAML
JSON and YAML are great for structured, hierarchical data like objects or nested records.
Lesson 544 — Fixture Files and Data Formats
You'll learn
The two fundamental approaches to creating API contracts—whether you design the contract upfront or generate it from your code.
Lesson 840 — Schema-First vs Code-First Design

Z

Zipkin
Jaeger and Zipkin are two popular open-source tracing backends.
Lesson 1153 — Tracing Infrastructure and Tools