GK One-Line Question & Answer

Output metrics (velocity, stories completed, sprints delivered) measure activity, not value delivered — a team can have high velocity while building features nobody uses; the iron law states that what matters is outcome metrics (user adoption, business KPIs, customer satisfaction) which output metrics don't capture and can even inversely correlate with

Cognitive load (Skelton, Pais) measures the total mental capacity a team needs to understand and operate the systems they own — team boundaries should be drawn so each team's domain fits within reasonable cognitive load (intrinsic, extraneous, germane), preventing teams from being responsible for more complexity than they can effectively reason about

Enforcing strict WIP limits forces teams to confront bottlenecks immediately rather than accumulating hidden queues — the psychological shift is from individual productivity ('I'm always coding something') to system throughput ('we finish things'), often producing initial discomfort as developers must help unblock others rather than start new work

A common failure pattern occurs when executives mandate agile and teams adopt ceremonies, but middle managers (whose traditional command-and-control role conflicts with self-organising teams) are neither retrained for new roles (coaching, removing obstacles) nor eliminated — creating organisational confusion where two incompatible management models coexist, undermining both

Checklists measure ceremony adoption (doing standups, having a backlog) but not the underlying values and outcomes (responsiveness to change, psychological safety, continuous learning, customer-centricity) — a team can check every box while remaining fundamentally rigid and command-driven (cargo cult agile)

A proxy product owner relays decisions from a 'real' decision-maker (often a business stakeholder unwilling to engage directly with the team) without having genuine authority to make prioritisation trade-offs — this indicates the organisation hasn't genuinely empowered the product owner role, causing decision delays and information loss through the relay chain

Interview bias occurs when the interviewer's questions, framing, or assumptions inadvertently shape stakeholder answers — leading questions ('don't you think the system should have feature X?') are mitigated by open-ended questioning techniques, asking stakeholders to describe current workflows before discussing solutions, and triangulating answers across multiple independent stakeholders

Win-Win negotiation seeks mutually satisfactory agreement among conflicting stakeholders, identifying creative compromises that satisfy multiple parties' underlying interests; prioritisation simply orders requirements by importance without resolving the underlying conflicts between stakeholder interests

Requirements smell (analogous to code smell) identifies surface patterns indicating underlying problems: vague adjectives ('user-friendly', 'fast'), conjunctions joining multiple requirements into one ('the system shall do X and Y'), passive voice obscuring responsibility, and unbounded superlatives ('all', 'every', 'never')

Requirements risk assessment specifically evaluates risks inherent to the requirements themselves: ambiguity risk (multiple interpretations possible), volatility risk (likely to change), feasibility risk (may not be technically achievable), and conflict risk (incompatible with other requirements) — distinct from general project risks like schedule or resource availability

REMM describes progression from ad-hoc (informal conversations, no defined process, requirements captured inconsistently) to systematic (defined elicitation techniques selected per stakeholder type, structured documentation templates, formal review and validation processes, traceability maintained throughout lifecycle)

Completeness means all necessary requirements (functional, non-functional, edge cases, error conditions) are specified — for complex systems it's theoretically impossible because: emergent requirements only become apparent through usage, unknown unknowns cannot be elicited in advance, and the cost of specifying every conceivable edge case exceeds its value

ML systems exhibit probabilistic, data-dependent behaviour that traditional deterministic acceptance criteria ('given input X, output shall be Y') cannot capture — requirements must instead specify acceptable performance distributions (accuracy thresholds, false positive/negative rate bounds), training data quality requirements, and fairness/bias constraints across demographic groups

Compliance requirements (GDPR, HIPAA, PCI-DSS) require demonstrable evidence that each regulatory clause maps to specific system requirements, which map to design elements, code modules, and verification tests — auditors must be able to trace 'GDPR Article 17 (right to erasure)' through this entire chain to verify compliance, far beyond typical functional requirement traceability

Enterprise RE tools provide formal traceability matrices, baseline/version comparison, regulatory compliance reporting templates, and bidirectional impact analysis across thousands of requirements — capabilities needed for safety-critical/regulated domains; lightweight tools optimise for fast iteration and collaboration in less formally regulated contexts

Requirements patterns (Withall's catalogue) provide proven templates for commonly recurring requirement types (e.g., 'the system shall validate <data> against <rule> and shall <action> if invalid') — using established patterns reduces errors by ensuring all necessary clauses (error handling, boundary conditions, audit logging) are systematically included rather than ad-hoc and incomplete

GORE starts from high-level organisational goals and systematically refines them into operational requirements through AND/OR decomposition trees — KAOS (Knowledge Acquisition in autOmated Specification) formally models goals, agents (who is responsible), obstacles (what could prevent goal achievement), and the requirements needed to overcome obstacles

EDA has services publish events to a broker (Kafka, RabbitMQ) without knowing which services consume them — producers and consumers are decoupled in time (consumer can be offline) and space (producer doesn't know consumer's address), enabling independent scaling and evolution of each service

CQRS separates the data model and code path for writes (commands) from reads (queries) — solving the problem where read-heavy and write-heavy workloads have conflicting optimisation needs (writes need normalisation/consistency, reads need denormalisation/speed), allowing each to scale and be optimised independently

DDD models software around business domains and their terminology; a bounded context defines the scope within which a domain model and its terminology (ubiquitous language) are consistent — it prevents the 'model conflation' problem where the same term (e.g., 'Customer') means different things in different parts of the system, causing confusion and design errors

An idempotent operation produces the same result whether executed once or multiple times — critical for payments because network failures cause clients to retry requests uncertain whether the original succeeded; without idempotency, retries could charge a customer multiple times for one purchase

Circuit breaker prevents cascading failures by monitoring calls to a downstream service and 'tripping' when failure rate exceeds a threshold — it cycles through: Closed (normal operation, calls pass through), Open (failures detected, calls fail immediately without attempting the downstream service), Half-Open (after a timeout, test calls are allowed to check if the service has recovered)

Saga pattern coordinates a sequence of local transactions across multiple services, each with a compensating transaction that undoes its effect if a later step fails — providing eventual consistency rather than ACID's immediate consistency, since there's no global lock across all services during the saga's execution

ACL is a translation layer isolating your domain model from an external system's (often legacy or third-party) different and potentially poor model — solving the problem where direct integration would force your clean domain model to absorb the external system's inconsistencies, naming conflicts, or design flaws

Each microservice owns and exclusively accesses its own database, with no other service allowed direct access — this enables service independence (schema changes don't break other services) but introduces the trade-off that queries spanning multiple services' data can no longer use simple SQL joins, requiring API composition or data duplication via events

Sidecar pattern deploys a helper container alongside the main application container (in the same pod) to handle cross-cutting concerns — typically: service mesh networking (mTLS, retries, load balancing via Istio/Linkerd), logging aggregation, and configuration management — without modifying the main application's code

The bulkhead pattern partitions system resources (thread pools, connection pools) into isolated groups so that failure or resource exhaustion in one partition doesn't cascade to others — drawn from ship bulkheads that compartmentalise the hull so a breach in one compartment doesn't sink the entire ship

At the architecture level, an intercepting facade (proxy/gateway) routes requests either to the legacy system or new system based on which functionality has been migrated — enabling incremental, low-risk migration where the legacy and new system coexist, with traffic gradually shifting feature by feature until the legacy system can be safely decommissioned

An API gateway centralises: authentication/authorisation (validate tokens once, not per service), rate limiting, request routing/composition, SSL termination, and response caching — removing the need for every individual microservice to implement these concerns redundantly, ensuring consistency and reducing per-service complexity

Hexagonal architecture uses dependency injection to invert control: the domain layer defines interfaces (ports) that infrastructure (adapters) implements, so the domain depends only on its own abstractions, never on frameworks/databases/UI — this keeps business logic testable in isolation and portable across infrastructure changes (swap MySQL for PostgreSQL without touching domain code)

Static analysis (SonarQube, ESLint) examines source code without executing it — catching style violations, null pointer risks, unused variables, complexity thresholds; dynamic analysis (profilers, sanitizers) examines behaviour during actual execution — catching memory leaks, race conditions, actual performance bottlenecks that only manifest at runtime

Linting analyses code for style and potential error patterns; over-aggressive enforcement (hundreds of strict rules, zero tolerance for any deviation) can create developer fatigue, encourage workarounds (disabling lint rules inline rather than fixing issues), and slow velocity disproportionate to the quality benefit gained

URL versioning (/api/v2/users) is visible, cacheable, and easy to test but clutters the URL space and implies the resource itself changed; header versioning (Accept: application/vnd.api+json;version=2) keeps URLs clean and resource-focused but is less visible/discoverable and complicates caching and manual testing

Conventional Commits structures messages as type(scope): description (e.g., 'feat(auth): add OAuth support', 'fix(api): handle null response') — this structured format enables automated semantic versioning (feat = minor bump, fix = patch bump, BREAKING CHANGE = major bump) and automated changelog generation directly from commit history

Exceptions optimise for the common-case happy path being unencumbered by error checking syntax (errors propagate implicitly up the call stack) but risk unhandled exceptions causing crashes if callers forget to catch; result types (Rust, functional languages) make error handling explicit in the function signature, forcing callers to handle or explicitly propagate errors at compile time, trading verbosity for compile-time safety

The rule of three (Martin Fowler, originally from Don Roberts) suggests waiting until similar code appears three times before extracting a shared abstraction — premature abstraction after seeing only two similar instances often produces the wrong abstraction because the pattern isn't yet clear; the third occurrence reveals which aspects are truly common versus coincidentally similar

NFR decomposition breaks abstract quality goals into specific, measurable sub-requirements; 'secure' is inadequate because it doesn't specify against which threats, to what assurance level, or how compliance would be verified — proper decomposition specifies: authentication method, encryption standards, access control model, audit logging requirements, each independently testable

Event sourcing persists every state-changing event (not just the current state) — providing complete audit trail (every change is recorded with who/when/why), the ability to reconstruct state at any point in history, and the ability to replay events to debug exactly how a corrupted state arose

This standard prefers immutable data structures (final/const/readonly) unless mutation is explicitly required — it eliminates entire categories of concurrency bugs because immutable data can be freely shared across threads without synchronisation (no data races possible if nothing can be written after creation)

Fail-fast immediately surfaces errors at the point of detection (throw on invalid state rather than continuing with corrupted data) — making bugs visible and traceable to their source; graceful degradation continues operating with reduced functionality when a component fails (show cached data if live data unavailable) — appropriate for user-facing resilience but inappropriate for catching programming errors during development