What you will learn in Grokking Software Architecture
A friendly guide for programmers and other curious people
Chapter by chapter
Chapter 1: The Architect's Compass: It's All About Tradeoffs
This chapter introduction previews the architecture concepts, decision-making process, and case study covered later.
What you learn in chapter 1 →Chapter 2: The Architect's Toolkit: A Guide to Defensible Decisions
The chapter introduction previews the decision-making tools and concepts covered in Chapter 2.
What you learn in chapter 2 →Chapter 3: The Principles of Sound Structure: From Code That Works to Code That Lasts
This chapter introduction previews the structural principles, code smells, refactoring example, and case studies covered later.
What you learn in chapter 3 →Chapter 4: Thinking in Layers: Separating the 'How' from the 'Why' at Scale
This chapter introduction previews the topics to be covered: architectural layers, downward dependencies, cross-cutting concerns, anti-patterns, and diagrams.
What you learn in chapter 4 →Chapter 5: Hexagonal Architecture: Protecting the Core: The Power of Ports and Adapters
This chapter introduction previews decoupling business logic from external systems and the vocabulary, diagram, code, and origins of hexagonal architecture.
What you learn in chapter 5 →Chapter 6: Reliable API Design: Public Contracts and Synchronous Communication
This chapter introduction previews API contracts, REST and GraphQL, AI-facing APIs, REST’s origins, and versioned endpoints.
What you learn in chapter 6 →Chapter 7: Event-Driven Architecture (EDA): Temporal Decoupling and Asynchronous Communication
This chapter introduction previews topics in event-driven architecture without explaining them.
What you learn in chapter 7 →Chapter 8: The Database as an Architectural Pillar: Choosing Between Strict Order and Massive Scale
This chapter introduction previews SQL, NoSQL, vector databases, normalization tradeoffs, and SQL injection without explaining them.
What you learn in chapter 8 →Chapter 9: Architecting for the Cloud: Trading Pets for Cattle and Concrete for Code
This chapter introduction previews cloud architecture topics, including disposable servers, compute tradeoffs, Infrastructure as Code, and automated services.
What you learn in chapter 9 →Chapter 10: Architecting for Resilience and Scale: Preparing for the Worst, Scaling for the Best
This chapter introduction previews resilience, scaling, and the risks of assuming systems will always work as expected.
What you learn in chapter 10 →Chapter 11: Foundational Security Architecture: Building the Fortress, Not Just the Fence
This chapter introduction previews the security concepts, architectural boundaries, credential protection, and attack analysis covered later in the chapter.
What you learn in chapter 11 →Chapter 12: The Great Debate: Monoliths vs. Microservices— Navigating the Distributed Divide
This chapter introduction previews the comparison of monoliths and microservices, legacy-system evolution, and the costs and failure risks of distributed architectures.
What you learn in chapter 12 →Chapter 13: Architecting for the Delivery Lifecycle (CI/CD): Building Automated Gates for High-Velocity Software Delivery
This chapter introduction previews the delivery-lifecycle topics covered later in the chapter.
What you learn in chapter 13 →Concepts explained in this book
- contractAn API contract specifies the operations, data, and behavioral expectations governing communication between an API and its clients.
- principle of least privilegeA security principle that grants users, processes, and systems only the permissions necessary for their required functions.
- couplingCoupling is the degree of dependency between software components, with tight coupling requiring extensive knowledge of another component's operations or internal structure.
- timeoutA time limit after which an operation is stopped rather than allowed to wait indefinitely.
- zero-trust architectureZero trust architecture is a system design that applies zero-trust principles through explicit verification and access controls.
- tradeoffA tradeoff is a situation in which gaining a benefit requires accepting a cost, risk, or limitation elsewhere.
- separation of concernsSeparation of concerns is a design principle that reduces complexity by dividing a system into distinct parts with separate responsibilities and boundaries.
- outbox patternA pattern that stores business data and an outgoing message in the same local transaction, then publishes the message asynchronously.
- architecture decision recordA document that records an architectural decision, its context, considered alternatives, and rationale.
- stateless systemAn architectural approach in which application servers avoid retaining state locally between requests, typically storing necessary state elsewhere.
- portA port is an application-facing interface in hexagonal architecture that defines operations used to interact with the application core.
- adapterA component in hexagonal architecture that connects a port to an external system or technology.
- infrastructure as codeInfrastructure as Code is the practice of defining and managing infrastructure through machine-readable configuration files rather than manual procedures.
- hexagonal architectureAn architectural pattern that isolates the application core from external systems through ports and adapters.
- eventual consistencyEventual consistency is a consistency model in which distributed state may temporarily differ but converges to a consistent state after updates propagate.
- testabilityTestability is the degree to which software can be easily tested to verify its behavior and correctness.
- application coreThe application core is the central part of a software system that contains its essential business logic while remaining isolated from external technical concerns.
- document databaseA database that stores and retrieves data as document-shaped records, often with flexible fields and nested structures.
- service layerThe architectural layer that coordinates application use cases and orchestrates interactions with domain and infrastructure components.
- securitySecurity is the protection of software systems and their data from unauthorized access, misuse, disruption, or alteration.
- platform as a serviceA cloud computing model that provides a managed platform for developing and deploying applications without managing the underlying infrastructure.
- single responsibility principleThe single responsibility principle is the design principle that a software unit should have one clearly focused responsibility and one primary reason to change.
- latencyLatency is the elapsed time between a request or input and the corresponding response or observable result.
- correlation idAn identifier shared across related operations, messages, or log records so their activity can be traced across components.
- software architectureSoftware architecture comprises the significant structural and behavioral decisions that shape how a software system is built, deployed, and changed.
- fallbackFallback logic provides an alternative behavior when a preferred operation or dependency fails.
- database normalizationA relational database design technique that organizes data to reduce redundancy and update anomalies.
- authorizationThe process of determining whether an identity has permission to perform an action or access a resource.
- sagaA pattern that coordinates a distributed business transaction as a sequence of local transactions with compensating actions for failures.
- retryA retry is a fault-tolerance technique that repeats a failed or apparently lost operation according to a defined policy.
- dependency inversionThe Dependency Inversion Principle states that high-level and low-level modules should depend on abstractions, while abstractions should not depend on implementation details.
- mutual TLSA TLS configuration in which both communicating endpoints authenticate each other using certificates.
- layered architectureA structural division of software with a defined responsibility and relationships to other divisions.
- synchronous callA synchronous operation blocks the initiating participant until the requested processing completes and a result is available.
- ACIDA database transaction that provides atomicity, consistency, isolation, and durability guarantees.
- schemaA formal description of the fields and structure of an event message.
- exponential backoffExponential backoff is a retry technique that increases the waiting interval after successive failures, typically by multiplying the interval by a constant factor.
- API gatewayAn API gateway is a centralized edge server that provides a single entry point for external clients and routes requests to internal services while enforcing shared perimeter concerns.
- scalabilityScalability is the ability of a system to maintain acceptable behavior as its workload or size increases.
- data integrityData integrity is the preservation of data's accuracy, completeness, consistency, and intended state.
- microserviceA microservice is an independently deployable service aligned with a specific business capability and communicating with other services through defined interfaces.
- choreographyChoreography is a distributed coordination style in which services react independently to events rather than following commands from a central coordinator.
- defensible decisionA defensible decision is a technical choice supported by an explicit rationale that accounts for relevant benefits, costs, risks, and alternatives.
- horizontal scalingIncreasing capacity by adding instances of a system component across multiple servers or processes.
- Liskov Substitution PrincipleThe Liskov Substitution Principle is an object-oriented design principle requiring instances of a subtype to remain behaviorally usable wherever instances of its parent type are expected.
- compensating transactionA transaction that applies a corrective action to counteract the effects of an earlier completed transaction.
- open-closed principleA software design principle stating that software entities should be open to extension but closed to modification.
- threat modelA threat model is a structured representation of potential attackers, attack paths, assets, and mitigations for a system.
- Fallacies of Distributed ComputingThe eight commonly cited false assumptions about networks and distributed environments, such as assuming that networks are reliable or have zero latency.
- strangler fig patternA gradual modernization technique that replaces a legacy system by moving functionality into a new system until the old system is no longer needed.
- monolithic architectureA software application developed and deployed as a single unified unit.
- blast radiusA blast radius is the extent to which a software failure, defect, outage, misconfiguration, security breach, or regulatory scope affects other components or the surrounding organization.
- maintainabilityMaintainability is the degree to which software can be understood, corrected, modified, or extended efficiently over time.
- access patternA repeatable way an application reads from and writes to its storage, including query shapes and read-to-write ratios.
- isolationArchitectural separation of a software component from external systems or unrelated concerns to contain changes and failures.
- foreign keyA foreign key is a relational database column or set of columns that references a key in another table to represent a relationship between records.
- primary keyA relational database key that uniquely identifies each row in a table and cannot contain a null value.
- relational database management systemA relational database management system is software that stores and manages data in related tables and supports relational queries.
- relational modelA data model that represents information as relations, commonly implemented as tables linked through shared values.
- database transactionA unit of database work treated as a single operation with defined consistency and recovery behavior.
- database migrationA controlled change to a database's structure, such as its tables or columns.
- object-relational mapperAn object-relational mapper is a technique or software layer that represents relational database data as programming-language objects and translates operations between the two models.
- TerraformTerraform is an infrastructure-as-code tool that declaratively provisions and manages resources across multiple cloud and infrastructure providers.
- cohesionCohesion is the degree to which the responsibilities within a software component belong together.
- abstractionAn abstraction is an interface or simplified representation that exposes relevant behavior while hiding implementation details.
- circuit breaker patternA circuit breaker is a resilience pattern that temporarily prevents calls to a failing dependency to limit cascading failures.
- idempotency keyA request identifier that lets a payment processor recognize repeated submissions as the same transaction rather than separate transactions.
- business logicBusiness logic is the application code that implements domain-specific rules and coordinates the system's behavior.
- message brokerA middleware component that receives, routes, and delivers messages between software components.
- dual-write modeA dual write is an operation that updates two separate systems, such as a database and a message broker, without a shared atomic commit.
- infrastructure layerThe architectural layer that implements external technical concerns such as persistence, messaging, and third-party communication.
- reliabilityThe degree to which a system performs its intended function consistently over time, including remaining available when required.
- blue-green deploymentBlue-green deployment is a release pattern that maintains separate current and replacement environments and switches traffic between them after verification.
- eventAn immutable representation of something that has happened and may be communicated to downstream consumers.
- serverless computingA cloud execution model in which the provider manages server infrastructure and allocates resources on demand.
- anticorruption layerA boundary pattern that translates between an external system's model and an application's domain model to prevent external concepts from affecting the domain model.
- serverA server is a software component that receives client requests, performs the requested processing, and returns responses.
- encapsulationEncapsulation is a design principle that keeps implementation details and process complexity inside the component responsible for them while restricting uncontrolled access to its state.
- deployment pipelineAn automated sequence of stages that builds, tests, and moves software changes toward deployment.
- sink nodeA component that subscribes to topics and receives messages published to them.
- cloud computingThe on-demand delivery of computing resources and services over a network, typically with scalable provisioning and usage-based billing.
- identity providerAn identity provider is a service that authenticates identities and issues credentials or assertions that other systems use for access decisions.
- defense in depthLayered defense is a security pattern that places multiple independent protective controls between an attacker and protected resources.
- downward dependency ruleThe Downward Dependency Rule requires dependencies between architectural layers to point only toward lower-level layers and never upward.
- architectural alignmentArchitectural alignment is the practice of keeping implementation decisions consistent with a system's architectural goals and constraints.
- architectural awarenessArchitectural awareness is recognition and understanding of the forces, priorities, and consequences that shape software architecture.
- architectural fitness functionA fitness function is an automated check that evaluates whether a software system conforms to a desired architectural property or constraint.
- aggregate orientationAggregate orientation is a data-modeling approach that groups related data and treats the group as a single atomic unit.
- BASEA distributed-data model characterized by basic availability, soft state, and eventual consistency.
- tunable consistencyTunable consistency is a database configuration that lets developers choose the consistency guarantees and response speed for a request.
- presentation layerThe part of an application that displays information, captures user input, and translates user interactions into application requests.
- interfaceAn interface is a programming-language construct that defines a contract of operations without prescribing their implementation.
- time-to-marketTime to market is the elapsed time required to deliver a product or feature to its intended users or market.
- service meshA service mesh is an infrastructure layer that manages service-to-service communication through dedicated networking components and centralized traffic policies.
- resilienceResilience is the ability of a system to recover from failures or disturbances and continue operating acceptably.
- consistencyConsistency is the property that observations of distributed data conform to a defined agreement about its current state.
- clientA software component that initiates communication with a server to request resources or operations.
- modular monolithA monolithic application organized into distinct modules with defined responsibilities and boundaries while remaining deployed as one unit.
- dead letter queueA dead letter queue is a specialized holding queue for messages that remain unprocessable after a defined number of delivery attempts.
- GraphQLGraphQL is an API query language and execution system that lets clients request structured data through a typed schema.
- CAP theoremThe CAP theorem states that a distributed system cannot simultaneously guarantee consistency, availability, and partition tolerance under network partition conditions.
- immutable infrastructureAn operational approach in which deployed infrastructure is changed by rebuilding and replacing instances rather than modifying them in place.
- software supply-chain attackA supply chain attack compromises a trusted supplier, dependency, build process, or distribution channel to reach downstream users.
- outbox tableAn outbox table is a database table that stores messages or events for later delivery by a separate process.
- CDCChange data capture is a technique for detecting and recording changes made to data stores so those changes can be propagated or processed.
- domain layerThe architectural part of an application that contains core business knowledge, rules, logic, state, entities, value objects, and domain services.
- egress controlEgress filtering is the control of outbound network traffic according to approved destinations, protocols, ports, or policies.
- performancePerformance is the measurable responsiveness and efficiency of a software system, including the time it takes to serve requests.
- availabilityThe duration or proportion of time a system remains operational.
- Terraform state fileA Terraform state file records the resources Terraform manages and maps its configuration to real infrastructure.
- technical debtTechnical debt is the future cost of short-term software design or implementation compromises made in favor of speed over quality and maintainability.
- client-server architectureA distributed architecture that separates clients that initiate requests from servers that provide resources or processing.
- joinA relational query operation that combines rows from tables according to a specified relationship or matching condition.
- driven adapterAn implementation outside the application core that translates a secondary port's contract into actions involving an external system.
- ClickOpsClickOps is the practice of managing infrastructure through manual interactions with graphical or web-based interfaces instead of reproducible automation.
- secrets managerA secrets manager securely stores and controls access to credentials, keys, and other sensitive values.
- endpointA public endpoint is an externally reachable interface through which clients can send requests to a system or service.
- tradeoff triangleThe Tradeoff Triangle is a decision-making tool for making competing project priorities visible and comparing their relative emphasis.
- software architectA person responsible for guiding the structural and system-wide design of software.
- parallel changeA database migration pattern that introduces compatible schema changes in stages so old and new application versions can operate during a rollout.
- ilitiesSystem qualities such as reliability, scalability, and maintainability that describe how a system behaves or can be operated.
- declarative data retrievalDeclarative querying is a data-access technique in which code specifies the desired result while a query processor determines how to retrieve it.
- dependency scanDependency scanning is the automated inspection of software dependencies for known vulnerabilities, malicious changes, or policy violations.
- infrastructure as code scanningInfrastructure scanning is the automated analysis of infrastructure definitions for security violations and unsafe configurations.
- network segmentationNetwork segmentation is the division of a network into isolated zones with controlled communication paths between them.
- policy as codePolicy as code is the representation and automated enforcement of operational or security rules in machine-readable code.
- secret scanningSecrets scanning is the automated detection of credentials, tokens, and other sensitive values embedded in source code or configuration.
- short-lived tokenA credential configured to expire after a brief period, limiting the usefulness of theft or compromise.
- software bill of materialsA software bill of materials is a machine-readable inventory of the software components and dependencies included in an application.
- static application security testingStatic application security testing is the automated analysis of application source or compiled code for vulnerabilities without executing the application.
- eager loadingEager loading is a data-access technique that retrieves an entity and its required related data in an intentionally combined operation.
- N + 1 query problemA database performance problem in which one query retrieves a collection and an additional query retrieves related data for each item.
- atomicityA transaction property requiring its operations to succeed or fail as a single indivisible unit.
- poison pillA malformed or otherwise unprocessable message that repeatedly fails when a consumer attempts to process it.
- configuration driftConfiguration drift is the gradual divergence of a system's actual settings from its intended configuration or from the configuration of equivalent environments.
- three a's of architectureA framework distinguishing architectural awareness, alignment, and accountability as responsibilities in architectural work.
- five-step architectural thinking processA repeatable five-step method for analyzing software requests and making reasoned architectural decisions before implementation.
- asynchronous programmingAn execution model in which work is initiated without requiring the caller to wait for its completion.
- microservice premiumThe microservice premium is the additional organizational, operational, and technical cost incurred by adopting microservices instead of a simpler architecture.
- deny-by-defaultDeny by default is a security policy in which access is rejected unless it is explicitly permitted.
- implicit trustImplicit trust is an access assumption that treats a request as trustworthy based on its location or origin without independently verifying it.
- sidecar patternThe sidecar pattern deploys a helper process alongside a primary application process to provide supporting infrastructure capabilities.
- certificateA cryptographic certificate binds an identity to a public key and is used to authenticate that identity in secure communication.
- SQL injectionSQL injection is an attack technique that inserts crafted input into an application's SQL statements to alter database operations or access data without authorization.
- driving adapterA hexagonal-architecture adapter that receives requests from outside the application, converts them into the core's terms, and calls a primary port.
- idempotencyIdempotency is the property of an operation whose repeated application has the same effect as applying it once.
- feature flagA feature flag is a runtime switch that changes application behavior without requiring a new deployment.
- SOLID principlesSOLID principles are a group of object-oriented design principles for improving software structure, flexibility, and maintainability.
- cachingCaching is the technique of temporarily storing reusable data or results to reduce latency or repeated computation.
- boundary keeperA Boundary Keeper is an architectural role responsible for preserving component boundaries and preventing responsibilities from leaking across them.
- explainer-in-chiefAn Explainer-in-Chief is an architectural role responsible for communicating the rationale behind technical choices in clear language.
- risk scoutA Risk Scout is an architectural role responsible for identifying and investigating technical risks before they impede development.
- system boundaryA separation that controls how responsibilities and dependencies cross between parts of a software architecture.
- JSON Web TokenJWT is a compact, URL-safe token format for representing claims that can be digitally signed or encrypted.
- producerA software component that emits an event or initiates an asynchronous operation for other components to process.
- partitionA subdivision of a message stream that can be processed independently, with ordering guarantees limited to that subdivision.
- rolling updateA deployment strategy that updates a system incrementally by replacing instances or servers over time.
- credential rotationSecret rotation is the practice of replacing credentials on a recurring or triggered basis while maintaining application access without unnecessary downtime.
- replication lagReplication lag is the delay before a data change becomes available in a replica or other asynchronously synchronized copy.
- execution planAn execution plan is the database engine's strategy for executing a query, including the operations and access methods it will perform.
- scribeA Scribe is an architectural role responsible for maintaining the documentation trail of decisions, assumptions, and operational details.
- databaseA database is a software system that stores, organizes, and retrieves persistent data.
- snapshot-and-stream workflowA data migration strategy that combines an initial bulk copy of existing records with ongoing capture and replay of subsequent changes.
- vector databaseA vector database is a database system optimized for storing, indexing, and querying numerical vector representations.
- canary deploymentA deployment strategy that gradually routes a controlled fraction of live traffic to a new software release before expanding the rollout.
- bullwhip effectThe bullwhip effect is a system-dynamics phenomenon in which small demand fluctuations at the edge of a network cause progressively larger fluctuations deeper within the system.
- polyglot persistenceAn architectural strategy that uses different data-storage technologies for different data needs.
- OAuthA version of the OAuth authorization framework that enables delegated, token-based access to protected resources.
- openid connectAn identity layer built on OAuth 2.0 that lets clients verify an authenticated user’s identity and obtain basic profile information.
- database indexAn auxiliary database data structure that accelerates retrieval by organizing references to rows according to selected values.
- observabilityObservability is the practice of making a distributed system's internal state inferable from externally emitted telemetry.
- accountabilityArchitectural accountability is responsibility for making and owning system-wide architectural decisions.
- clarity engineerA Clarity Engineer is an architectural mindset centered on asking questions that make software decisions and their implications easier to understand.
- STRIDESTRIDE is a threat-modeling framework that classifies security threats as spoofing, tampering, repudiation, information disclosure, denial of service, and elevation of privilege.
- staging environmentA pre-production environment intended to simulate production conditions for validating software before release.
- rate limitA rate limiter restricts the number or frequency of operations permitted from a client or source during a defined interval.
- rest apiA REST API is a web API designed around resources and the constraints of Representational State Transfer.
- happy pathThe happy path is the expected execution flow in which inputs, dependencies, and operations succeed without exceptional conditions.
- iaasInfrastructure as a service (IaaS) is a cloud model that provides virtualized computing, storage, and networking resources for customers to manage and use.
- RESTRepresentational State Transfer is an architectural style for networked applications based on resources, a uniform interface, and stateless interactions.
- temporal dependencyA dependency in which one software component must be available or synchronized at a particular time for another component to complete an operation.
- immutabilityImmutability is a system property in which deployed infrastructure is not modified in place but replaced with a new version when changes are required.
- data layerA data layer isolates data access and persistence operations from other application responsibilities.
- fat controllerA fat controller is a controller design in which presentation-layer code accumulates excessive business logic and coordination responsibilities.
- Interface Segregation PrincipleThe Interface Segregation Principle states that a class should not be required to depend on or implement interface methods it does not use.
- message queueAn intermediary buffer that holds messages for consumers to retrieve and process.
- dependency injectionInjection is the process of providing a dependency to the object that needs it.
- deployabilityDeployability is the degree to which software can be reliably and efficiently delivered to a target environment.
- four-layer architectureA four-layer architecture organizes an application into presentation, application, domain, and infrastructure layers with distinct responsibilities and dependencies.
- aspect-oriented programmingA programming technique that modularizes cross-cutting concerns and automatically applies them at designated join points in program execution.
- secondary portA contract defined by an application core for functionality it requires from an external system.
- cold start problemA cold start is the startup latency incurred when a serverless runtime must initialize an execution environment and load function code before handling an invocation.
- sketchA sketch is an informal architecture diagram that represents a system’s main responsibilities and relationships without the formality of a UML diagram.
- sidecar proxyA sidecar proxy is a supporting network proxy deployed alongside an application instance to handle communication and infrastructure concerns.
- reason for changeA distinct requirement, action, or area of concern that can independently require a software unit to be modified.
- testing in productionValidating software on production infrastructure, potentially using controlled exposure to real user traffic.
- asynchronous flowAsynchronous flow is a processing model in which work continues independently after the initiating interaction has completed.
- physical separationPhysical separation deploys application parts onto different machines or processes that communicate across execution boundaries.
- JSONA text-based data interchange format representing structured data with objects, arrays, strings, numbers, booleans, and null.
- multifactor authenticationMulti-factor authentication is an authentication method that requires evidence from two or more independent credential factors.
- validationData validation is the enforcement of rules that determine whether stored values are valid and conform to required constraints.
- distributed monolithA distributed monolith is a system whose deployable units are separated across processes or machines but remain tightly coupled through shared data or synchronous call chains.
- aggregateAn aggregate is a group of related data treated as a single unit for storage and operations.
- wide-column storeA wide-column database stores data in rows with flexible groups of columns, often distributed across many machines.
- distributed key-value storeA data store that stores and retrieves values using unique keys.
- quorumA quorum is a required majority of replicas that must acknowledge an operation before it is considered successful.
- soft stateSoft state is distributed system state that can change over time without new input as replicas synchronize.
- multi-level cachingMulti-level caching is a caching technique that organizes multiple cache layers with different locations or performance characteristics.
- retrieval-augmented generationRetrieval-augmented generation is an architecture that retrieves relevant external information and supplies it as context to a generative AI model before response generation.
- messageA message is a structured unit of information exchanged between software components or distributed systems.
- redundancyRedundancy is the provision of duplicate or alternate components or resources so a system can continue operating after a failure.
- SQLSQL is a standardized language for defining, querying, and manipulating data in relational database systems.
- architectural decisionAn architectural decision is a choice that materially shapes a software system's structure, behavior, or quality attributes.
- bulkheadA resilience pattern that isolates resource capacity into compartments so a failure or slowdown in one area does not exhaust resources elsewhere.
- NoSQL databaseA database system that does not primarily use the relational table-and-SQL model and commonly supports a nonrelational data model.
- cross-cutting concernA software responsibility that spans multiple architectural layers rather than belonging to just one.
- deploymentDeployment is the act of placing software files or components into an environment where they can run.
- releaseA release is the product decision or action that makes software functionality available to its intended users.
- deployment validationA release check that confirms a deployment reached its intended targets and that they are running the matching build.
- event-driven architectureA software architecture in which components communicate and trigger processing by producing and consuming events.
- change failure rateChange failure rate is the proportion of software changes that result in a failure requiring remediation or rollback.
- decision scribeA Decision Scribe is an architectural role responsible for recording significant team decisions and their rationale.
- leaky abstractionA leaky abstraction is an abstraction whose underlying implementation details or limitations remain observable to its users.
- rich domain modelA software design approach in which domain objects contain substantial business behavior and enforce domain rules rather than serving only as data containers.
- DORADORA metrics measure software delivery performance through deployment frequency, change lead time, change failure rate, and recovery time.
- architectural sovereigntyThe property of an application core having authority over its business rules without depending on external databases, frameworks, or infrastructure.
- infinite hangAn infinite hang is an operation that waits indefinitely because no completion or failure deadline is enforced.
- inversion of controlInversion of control is a design principle in which control over object creation or execution flow is transferred from a component to an external mechanism.
- versioningVersion control is the systematic management of changing files and their history so changes can be reviewed, reproduced, and restored.
- inheritanceInheritance is an object-oriented language feature that allows a new class to acquire properties and methods from an existing class.
- object-oriented programmingA programming paradigm that organizes software around objects containing state and behavior, commonly using classes, encapsulation, inheritance, and polymorphism.
- polymorphismPolymorphism is an object-oriented language feature allowing different objects to respond to the same operation according to their own implementations.
- network taxThe network tax is the added latency, failure exposure, security burden, consistency difficulty, and observability cost caused by communication across distributed boundaries.
- vertical scalingIncreasing the capacity of a single system instance by adding resources such as processing power, memory, or storage.
- containerAn isolated, portable execution environment that packages an application with its dependencies while sharing the host operating system kernel.
- constraintA practical limitation imposed by a project's operating context, such as available resources or environmental conditions.
- ai serviceAI as a service (AIaaS) provides access to AI capabilities through managed cloud services or APIs.
- integer overflowInteger overflow is the condition in which an integer computation or conversion produces a value outside the representable range of the target integer type.
- object storeAn object store is a persistent storage system that manages data as individually addressable objects with associated metadata.
- interface bloatInterface bloat is an interface design problem in which one interface combines excessive or unrelated operations that force clients to depend on methods they do not need.
- blocking chainA blocking chain is a sequence of dependent operations in which delay or failure in one operation prevents subsequent operations from proceeding.
- similarity searchSimilarity search retrieves items whose numerical representations are close to a query representation in a vector space.
- embeddingA numerical representation that maps an input such as text or an image into a vector space so semantic relationships can be measured.
- PACELC theoremPACELC is a model of distributed-system tradeoffs that considers latency and consistency during normal operation as well as availability and consistency during a partition.
- identity and access managementIdentity and access management comprises policies and controls for verifying identities and authorizing their access to resources.
- retry stormA retry storm is a burst of repeated requests generated by concurrent retries that overload an already struggling dependency or service.
- lockingA database mechanism that restricts concurrent access to data to protect consistency during operations.
- controllerA controller is an application component that receives requests and coordinates processing between the user interface and application logic.
- virtual machineA virtual machine is a software-defined computer that emulates a physical machine and runs an operating system with allocated virtual resources.
- write penaltyA write penalty is the additional latency incurred when database modifications require indexes to be maintained.
- dark launchA continuous delivery deployment technique in which software is shipped to production while concealed from and inaccessible to general users.
- backend-for-frontend patternA design pattern that provides a dedicated API tailored to a specific user interface or client.
- containers as a serviceContainers as a service (CaaS) is a cloud model that provides managed infrastructure and facilities for deploying and operating containers.
- resourceA resource is a web-accessible entity identified by a uniform resource identifier and manipulated through standardized operations.
- environment variableAn environment variable is a named runtime setting supplied through the process environment rather than embedded in application source code.
- payloadA payload is the data carried in a request or response, apart from the communication’s control information.
- logical layerLogical separation organizes code into distinct responsibility-based groups without requiring separate deployment locations.
- Conway's lawConway's law is the observation that a system's architecture tends to reflect the communication structure of the organization that designs it.
- JSON Web Key SetA JSON Web Key Set is a JSON document containing public cryptographic keys used to verify signed tokens.
- none attackThe alg none exploit is a JWT attack in which an implementation accepts a token declaring no signature algorithm and therefore skips signature verification.
- Proof Key for Code ExchangePKCE is an OAuth 2.0 security extension that binds an authorization request to a client-generated code verifier to protect public clients from intercepted authorization codes.
- indexingThe creation and maintenance of auxiliary structures that help a database locate records efficiently.
- componentA component is a modular software unit that encapsulates related functionality and interacts with other units through defined boundaries.
- half-open stateA circuit-breaker state that allows limited test calls to determine whether a failed dependency has recovered.
- client-side evaluationClient-side evaluation is the execution of a query operation in application memory rather than by the database engine.
- distributed cachingA distributed cache is a cache whose stored data is shared across multiple networked processes or machines.
- lazy initializationLazy loading is a loading strategy that retrieves related data only when the application first accesses it.
- acknowledgmentAn acknowledgment is a protocol signal indicating that a message or event has been successfully received or processed.
- S.O.S. testA decision-screening heuristic that checks whether a choice is significant, onerous to change, or surprising.
- layer skippingLayer skipping is a dependency shortcut in which a component bypasses one or more intervening architectural layers.
- upward dependencyAn upward dependency is a dependency from a lower software layer to a higher one.
- cacheabilityCacheability is the property that a response can be stored and reused for equivalent subsequent requests according to explicit freshness and validity rules.
- contract testingAn individual test that verifies a component conforms to an agreed behavioral contract.
- AWS Secrets ManagerAWS Secrets Manager is an AWS service for storing, retrieving, and managing application secrets.
- credential compromiseSecret compromise is the unauthorized exposure or acquisition of a credential that could enable access to protected systems or data.
- incident response guidelineAn incident response plan is a documented set of actions for detecting, containing, investigating, and recovering from a security incident.
- data streamAn event stream is an ordered sequence of events representing changes, observations, or occurrences over time.
- environment promotionA software delivery practice that advances the same built artifact through a sequence of increasingly production-like environments.
- cloud architectureCloud architecture is an approach to designing software systems to run on elastic, on-demand cloud infrastructure.
- sparkThe Spark is the initial feature request or observed problem that starts architectural discovery.
- architectural qualityArchitectural quality is the set of system properties that characterize how well an architecture satisfies important operational and developmental objectives.
- at-least-once deliveryA messaging guarantee under which a message is delivered one or more times, allowing duplicates.
- HTTP GETAn HTTP method that requests a representation of a resource without requesting a state change.
- HTTP PUT methodPUT is an HTTP method for creating or replacing the representation of a resource at a specified target URI.
- tierA tier is a physically deployable part of an application separated from other parts by a process or network boundary.
- container imageA container image is an immutable packaged artifact containing an application and the dependencies needed to run it in a container.
- automated guardrailAn automated gate is a machine-enforced check that must pass before a software change can proceed through delivery.
- finopsA collaborative practice for managing and optimizing cloud spending across engineering, finance, and business teams.
- composabilityComposability is a system design principle in which components can be selected and assembled in various combinations to satisfy specific user requirements.
- remote stateRemote state is infrastructure-as-code state stored in shared external storage rather than on an individual operator's local machine.
- multitenancyMulti-tenancy is an architecture in which a shared software system serves multiple customers or tenant organizations while maintaining separation of their data and workloads.
- noisy neighbor problemPerformance or availability degradation caused when one tenant consumes resources shared with other tenants.
- premature optimizationPremature optimization is optimizing software before a measured performance bottleneck justifies the change.
- credentialA credential is information or an authorization artifact used to establish identity or obtain access to a protected resource.
- declarative programmingA programming approach that specifies the desired result or state rather than the steps to produce it.
- primary portAn interface through which an external actor invokes an application's core functionality.
- anemic domain modelAn anemic domain model is a domain model whose objects contain little or no domain behavior, leaving rules in other components.
- complexity taxThe additional implementation complexity and maintenance burden incurred by adopting a more decoupled architectural structure.
- dry runA dry run previews the effects of an operation without applying its changes.
- refactoringRefactoring is the disciplined restructuring of existing code without changing its externally observable behavior.
- logThe recording of software events, states, or diagnostic information for operational analysis.
- agent orchestrationOrchestration is the coordination of multiple tasks or operations by a central service that directs when other services act.
- code spikeA small, targeted technical experiment for resolving uncertainty before committing to an implementation path.
- circular dependencyA cycle in which components depend on one another, directly or through other components, forming a closed dependency path.
- data flowData flow is the movement of information between software layers or components, potentially in multiple directions.
- GraphQL mutationA GraphQL operation that requests a change to server-side data or state.
- GraphQL queryA GraphQL query is an operation that requests data without changing it.
- classA programming construct that defines the properties and behavior shared by its object instances.
- dependencyA relationship in which one software component relies on another.
- service-level agreementA service-level agreement is a formal commitment defining expected service performance and availability between a provider and a customer.
- data modelA representation of the data structures, attributes, and relationships that an application stores and manipulates.
- secret managementSecrets management is the practice of securely storing, controlling access to, distributing, and rotating sensitive authentication data such as passwords and database credentials.
- operational burdenThe additional work, resources, and complexity required to operate and maintain a software system.
- HTTP methodA standardized token specifying the action requested on an HTTP resource, such as GET, POST, or DELETE.
- cloud-native architectureCloud-native architecture is an architectural approach that treats infrastructure as replaceable and designs explicitly for distributed operation, automated management, and failure.
- software testingTesting is the systematic evaluation of software behavior against expected requirements or properties.
- enumA programming-language type that restricts a value to a predefined set of named options.
- graceful failureA resilience pattern in which a system continues providing reduced functionality when components or dependencies fail.
- exceptionA runtime event representing an abnormal condition that interrupts normal program execution.
- trade-off triangleA decision model that represents competing priorities as the corners of a triangle, making the tension among them explicit.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
