iSAQB Software Architecture - Foundation Level (CPSA-F)

A software architect is responsible for architectural qualities that are strongly shaped by structure, communication, deployment, and key design decisions. Performance is one of those qualities because choices such as distribution, caching, concurrency, data access, resource ownership, and component boundaries can make later performance work easy or extremely difficult. The architect does not implement every optimization, but the architecture creates the conditions in which performance goals can be met.

The suitability of the design for its purpose is also central. Architecture translates requirements, constraints, and quality goals into a solution structure that can support the intended business and technical use. Technical implementation quality matters, but it is shared with developers and depends on coding, reviews, tests, and engineering discipline at a finer level. Defect freedom cannot be guaranteed by architecture or by any single role. The architect should identify risks, support testability, and guide quality tradeoffs, yet the final absence of errors is not a realistic responsibility. This distinction helps separate architectural accountability from implementation and verification responsibilities.

A runtime view is the documentation view most directly suited to understanding how important building blocks cooperate while a user request is processed. It describes behavior during execution: which building block receives a request, which collaborators are called, what data or messages move between them, where decisions are made, and what happens in important scenarios. This view can be expressed with sequence diagrams, activity descriptions, flow-oriented diagrams, or carefully written scenario steps depending on the audience and needed level of precision.

A building-block view that lists only static decomposition is useful, but it answers a different question. It explains what the system is made of, not how the pieces collaborate over time. A glossary defines terms and can support communication, yet it does not show runtime behavior. A meeting record is project history, not an architectural behavior view. The distinction matters because a team may understand all building blocks and still misunderstand the order of interactions. Runtime documentation connects static structure to actual system behavior under meaningful use cases.

Proposed correct regions:
- Architectural objectives and project objectives need to be identical -> false
- Architectural objectives are usually more long-term than project objectives -> true
- Both kinds of objectives need negotiation among concerned parties -> true
- Architectural objectives are a subset of project objectives -> true

Project objectives include schedule, budget, scope, delivery risk, staffing, business value, compliance, and other concerns that reach beyond the software structure. Architectural objectives focus on how the system should be shaped so it can meet important functional and quality goals over time. Because these scopes differ, the two sets of objectives do not need to be identical. A project may have a short delivery objective, while the architecture may also pursue maintainability, evolvability, and operational stability that continue to matter after the first release.

Architecture objectives are still connected to the project. They should support project success and therefore can be viewed as a specialized part of the broader project objective set. They also require negotiation because quality goals compete with cost, time, technology constraints, and stakeholder priorities. If architects choose objectives without project management and stakeholder agreement, they may optimize qualities that the project cannot fund or does not value. If project management ignores architectural objectives, later change and operation can become expensive. The useful relationship is alignment through explicit discussion.

Communicating architecture to different stakeholders requires selecting information that matches their concerns. Audience-specific views help because developers, testers, operations staff, security reviewers, managers, and product stakeholders ask different questions. A building-block view may help developers understand responsibilities, while a deployment view may help operations reason about runtime environments. Consistent architectural terms across the documentation are also important. When the same concept has different names in different sections, readers may think separate things are being described.

Explaining important decisions and consequences in plain language supports shared understanding. Stakeholders need to know why a structure was chosen, what tradeoffs it creates, and what risks remain. Hiding the reasons for decisions weakens trust and makes future maintenance harder because later teams cannot judge whether assumptions still apply. Replacing all written documentation with informal verbal updates is also insufficient. Conversation is useful, but written records preserve rationale and make architecture accessible to people who were not present. Good communication combines stakeholder-oriented views, stable terminology, and clear decision reasoning.

Interactions of runtime building blocks are best explained with notations that show behavior over time. Activity diagrams are useful when the focus is flow of control or parallel activities among collaborating elements. Sequence diagrams are especially strong when the reader must understand messages between participants in chronological order. Flowcharts can express ordered decisions and processing steps in a compact form. Numbered sequential steps are also suitable when a lightweight textual description communicates the runtime collaboration more clearly than a formal diagram.

State diagrams serve a different purpose: they describe the lifecycle of one object or component as it moves between states. That can support runtime reasoning, but it is less direct for showing the interaction among multiple building blocks. Class diagrams describe static types and relationships, not runtime collaboration. Interface tables define contracts and signatures, while screen-flow depictions concentrate on user navigation. The point being tested is the difference between static structure and dynamic behavior. When the concern is how runtime blocks interact, choose behavioral and sequence-oriented representations that make order, responsibility, and collaboration visible.

Proposed correct regions:
- The project plan is influenced by architectural decisions -> true
- Cost estimates are primarily the architect's responsibility -> false
- Architects advise project management on work packages -> true
- Management and architects cooperate on technical risks -> true

Architecture and management are connected because structural decisions affect planning. A decision to build a distributed system, introduce a new technology, isolate components, or migrate data changes work packages, sequencing, risks, and staffing needs. Project management therefore needs architectural input when planning the work. Architects can advise how responsibilities should be grouped, which technical dependencies should be handled first, and where early prototypes or risk-reduction tasks are needed.

Cost estimates are not primarily the architect's sole responsibility. Estimation involves management, product ownership, development teams, procurement, operations, and sometimes suppliers. Architects contribute technical assumptions, complexity drivers, and risk information, but management owns the broader planning and budgeting process. Cooperation on technical risks is essential because risks such as performance bottlenecks, integration uncertainty, skill gaps, or unsuitable infrastructure can affect schedule and cost. A healthy project treats architecture as a planning input and project constraints as architecture inputs. Neither side can make reliable decisions in isolation.

Proposed correct regions:
- Information hiding increases flexibility for modifications -> true
- It deliberately hides information from callers or consumers -> true
- It makes interface and implementation harder to distinguish -> false
- It derives from incremental refinement along the control flow -> false
- It is primarily relevant at class level in object-oriented development -> false

Information hiding means that a building block exposes a stable contract while concealing internal decisions that consumers do not need to know. This improves flexibility for modifications because internal data structures, algorithms, helper components, and implementation strategies can change without forcing every caller to change. It deliberately hides information from consumers, but not to make the system mysterious. The goal is to reduce dependency on decisions that should remain local to the owning building block.

The principle actually makes interface and implementation easier to distinguish. The interface states what clients may rely on; the implementation contains the hidden details. It is not a derivative of refining control flow, and it is not limited to classes. Information hiding applies to modules, services, components, packages, subsystems, and architecture boundaries. In larger architectures it is one of the main tools for controlling coupling and change propagation. A useful design exposes what collaborators need and protects everything else behind a clear boundary.

When requirements are incomplete, components should be designed so future change does not spread unnecessarily through the system. Weak coupling helps because a component can evolve behind a stable interface with fewer ripple effects on neighboring components. Strong cohesion helps because related responsibilities live together, making each component easier to understand, test, replace, and extend. Openness for extension is also important because new requirements can be added through planned variation points or controlled extension mechanisms instead of repeated invasive changes.

Meaningful names are useful, but names alone do not make a component resilient to requirement change. Small size can help comprehension, yet size by itself is not the design target; a small component with scattered responsibilities or tight dependencies can still be hard to change. The architectural issue is managing volatility. Components should have clear responsibility, limited knowledge of one another, and boundaries that allow the team to refine behavior as new requirements appear. That combination reduces rework and makes early architectural work compatible with later learning.

When requirements are incomplete, architecture work can still begin, but it must handle assumptions explicitly. Stating assumptions and related risks makes early decisions reviewable. For example, the team may assume expected load, integration protocols, data sensitivity, or deployment constraints, but those assumptions should be visible so stakeholders can confirm or correct them. Risks should be tracked because a wrong assumption can invalidate a decomposition, technology choice, or quality tradeoff.

Iterating on the architecture as requirements and constraints become clearer is also appropriate. Early architecture should focus on important drivers, risky decisions, and flexible boundaries rather than pretending every detail is final. Iteration allows the team to refine views, interfaces, deployment decisions, and quality scenarios as evidence appears. Freezing the first complete structure would turn early guesses into unnecessary constraints and make later learning expensive. Ignoring quality requirements until implementation is finished is equally dangerous because qualities such as performance, security, availability, and modifiability are often determined by early structural choices. Good architecture under uncertainty is deliberate, documented, and adaptable.

Understandability is a first-class quality characteristic for architecture documentation because the document is only useful when its intended readers can apply it. A document can contain many diagrams and still fail if developers, testers, operations staff, or managers cannot determine what decisions were made and why those decisions matter. Correctness is needed because wrong documentation leads to wrong implementation choices. Efficiency is relevant in the documentation sense: readers should be able to find the information they need without excessive effort or unnecessary detail.

Scope and completeness also affect understandability. If the document omits important interfaces, quality requirements, deployment assumptions, or architectural decisions, readers will fill gaps differently and the architecture becomes harder to communicate. If it includes material far outside its intended purpose, the important structure becomes buried. Simplicity and brevity can improve readability, but they are not enough by themselves; an overly short document may omit essential architectural facts. The key idea is that understandable documentation balances accurate content, appropriate scope, sufficient completeness, and economical presentation for its audience.