Application Architecture
Application architecture defines how a software system is structured internally: its layers, components, communication patterns, and boundaries. It determines how code is organized, how concerns are separated, and how the system evolves as requirements change.
itEnterprise architecture and integration | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Application Architecture
Application architecture is the set of decisions that determines how one application is arranged, how its parts cooperate, and how those choices behave when the day becomes more exciting than the diagram suggested. It is not a ceremonial box collection. It is the reason a change stays local, or starts touring every team like a particularly determined tax inspector.
Start with one outcome. An actor enters through an entry point, a business capability does work, and state changes or an integration responds. The boxes own responsibilities. The arrows create dependencies. Every arrow needs a contract, an owner, and a failure story, because a line without those is a wish wearing an arrowhead.
The first useful surprise is that “boundary” has several meanings. A code boundary controls dependencies. A runtime boundary tells you what fails together. A deployment boundary tells you what releases together. A data boundary decides who owns a fact and its invariants. A trust boundary marks where identity or privilege changes. They can align, but nobody issued a law requiring them to do so. Two tidy services can still be joined at the database hip.
An architecture style is not a personality test. Layers, queues, independently deployed services, and events all impose constraints. A queue can buffer work and separate a user response from long processing, but it also requires retries, duplicate handling, and visibility. Services can isolate faults and release independently, but the network brings latency, partial failure, contract evolution, and distributed data trouble. The question is whether the benefit pays for the trouble it introduces.
That is why quality scenarios matter. “Fast” and “reliable” are compliments, not evidence. Name the stimulus, affected part, response, and measure. Then trace that scenario through a context, container, runtime, or deployment view. Use the view that answers the stakeholder concern; one enormous diagram usually answers no one, except perhaps the person who enjoys zoom controls.
Finally, record consequential choices in an architecture decision record, then test assumptions with prototypes, load and failure tests, dependency rules, telemetry, and incidents. The intro explains the full mental model and style costs. The slides keep relationships visible. The cheatsheet is the compact review aid. The practice session turns a quality scenario into two candidate designs. Architecture continues after release, because evidence is allowed to disagree with plans. It is very considerate of evidence to be so honest.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.sei.cmu.edu/software-architecture/
Supports
- Architecture as decisions about overall system structure and behavior
- Architecture analysis against modifiability, availability, and security
- Documentation of architectural elements and interrelationships
- Repeated evaluation against business and mission goals
- Deployed-system conformance analysis and continuous evolution
- https://www.sei.cmu.edu/library/the-architecture-tradeoff-analysis-method/
Supports
- Structured architecture evaluation against competing quality attributes
- Interactions among modifiability, security, performance, and availability
- Candidate architecture analysis, risk mitigation, and refinement
- Quiz answers about measurable qualities and quality trade-offs
- https://www.sei.cmu.edu/library/an-introduction-to-software-architecture/
Supports
- Architecture as organization of systems built from many components
- Common architectural styles and their combination in one design
- Architectural representations as aids to understanding complex systems
- https://www.iso-architecture.org/ieee-1471/cm/
Supports
- Stakeholders as holders of concerns
- Viewpoints as conventions that frame concerns
- Views as expressions of architecture from stakeholder perspectives
- Architecture descriptions containing multiple architecture elements
- https://www.iso-architecture.org/ieee-1471/ads/
Supports
- Architecture descriptions identifying stakeholders and fundamental concerns
- Coverage of concerns through viewpoints and views
- Consideration of users, operators, owners, developers, and maintainers
- Inclusion of architecture evaluation results
- https://c4model.com/
Supports
- Hierarchical abstractions of software systems, containers, components, and code
- System context, container, component, and code diagrams
- Supporting system landscape, dynamic, and deployment diagrams
- Notation-independent and tooling-independent use
- https://c4model.com/diagrams
Supports
- Different zoom levels for different audiences and stories
- Context and container diagrams as sufficient for many teams
- Scope and audience distinctions among architecture diagrams
- Quiz distinction between code and deployment representations
- https://learn.microsoft.com/en-us/azure/architecture/guide/
Supports
- Evaluation through reliability, security, cost, operations, and performance lenses
- Architecture styles and data models selected after business and quality requirements
- Compute, data store, and messaging as major technology decisions
- Design patterns as repeatable approaches to processing and data storage
- https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/
Supports
- Architecture styles as shared characteristics and design constraints
- N-tier separation into presentation, business logic, and data access
- Web-queue-worker separation of interactive and long-running work
- Independent service deployment, fault isolation, and private service data
- Event-driven producer and consumer decoupling
- Messaging challenges involving eventual consistency and duplicate messages
- Microservice communication and manageability costs
- Style selection from business drivers and prioritized quality requirements
- https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/event-driven
Supports
- Event producers, consumers, and event channels
- Producer and consumer decoupling
- Distinction between broadcast events and mediator-dispatched commands
- Ordering, idempotency, error handling, observability, and schema evolution challenges
- Eventual consistency as an explicit architecture trade-off
- Combination of event-driven and other architecture styles
- https://learn.microsoft.com/en-us/azure/architecture/microservices/design/data-considerations
Supports
- Private service data stores and avoidance of shared-schema coupling
- Shared schemas as a source of coordinated changes across services
- Single sources of truth and explicit consistency requirements
- Event schemas and propagation of changes across service boundaries
- Redrawing boundaries when services become chatty and tightly coupled
- https://docs.aws.amazon.com/wellarchitected/latest/framework/definitions.html
Supports
- Architecture evaluation through consistent questions and best practices
- Operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability pillars
- Components working together to deliver workload requirements
- Quality trade-offs driven by business context
- https://martinfowler.com/bliki/ArchitectureDecisionRecord.html
Supports
- ADR as a short record of one consequential decision
- Decision, context, and significant ramifications as core content
- Accepted records preserved and linked to superseding records
- Decision records as aids to later understanding and current group reasoning
- https://dl.acm.org/doi/10.1145/361598.361623
Supports
- Enrichment artifact claims for application architecture
- https://www.sciencedirect.com/science/article/pii/S016412129600495X
Supports
- Enrichment artifact claims for application architecture
- https://www.wiley.com/en-us/Pattern+Oriented+Software+Architecture%2C+Volume+1%3A+A+System+of+Patterns-p-9780471958697
Supports
- Enrichment artifact claims for application architecture
- https://standards.ieee.org/ieee/1471/2187/
Supports
- Enrichment artifact claims for application architecture
- https://www.sei.cmu.edu/library/atam-method-for-architecture-evaluation/
Supports
- Enrichment artifact claims for application architecture
- https://c4model.com/history
Supports
- Enrichment artifact claims for application architecture
- https://www.iso.org/standard/50508.html
Supports
- Enrichment artifact claims for application architecture
- https://cognitect.com/blog/2011/11/15/documenting-architecture-decisions
Supports
- Enrichment artifact claims for application architecture
- https://martinfowler.com/microservices/
Supports
- Enrichment artifact claims for application architecture
- https://structurizr.com/
Supports
- Enrichment artifact claims for application architecture
- https://icepanel.io/
Supports
- Enrichment artifact claims for application architecture
- https://sparxsystems.com/products/ea/
Supports
- Enrichment artifact claims for application architecture
- https://backstage.io/
Supports
- Enrichment artifact claims for application architecture
- https://www.leanix.net/
Supports
- Enrichment artifact claims for application architecture
- https://netflixtechblog.com/the-making-of-ves-the-cosmos-microservice-for-netflix-video-encoding-946b9b3cd300
Supports
- Enrichment artifact claims for application architecture
- https://engineering.atspotify.com/2019/10/solving-documentation-for-monoliths-and-monorepos
Supports
- Enrichment artifact claims for application architecture
