Systems Architecture

Systems architecture is the part of systems engineering that decides what a system's major parts are, what each is responsible for, and how they will connect—before the parts are built in detail.

7 frameworks, from 1955 to today · Systems Engineering · Engineering

still a working view ended · each leads to its entry below

Overview

Systems architecture is the part of systems engineering that decides what a system's major parts are, what each is responsible for, and how they will connect—before the parts are built in detail1. Its practitioners work at the level where a decision is expensive to reverse: whether a vehicle carries one central computer or a network of small ones, whether a satellite's power and data flow through shared buses or dedicated lines, whether a software platform is one monolith or a set of services. The architect's product is not a component but a description: a set of views, models, and rationales that lets hundreds of engineers and suppliers build compatible pieces of something none of them can see whole. What is at stake is leverage. A good architecture makes later work cheap and change survivable; a bad one locks in costs and interfaces that no amount of downstream effort can undo. The history of the subfield is largely the history of how engineers learned to describe such wholes rigorously—and of the competing ideas about what a description should contain.

Decomposition: From Whole to Parts and Back

The founding move of systems architecture is functional decomposition: breaking a system's overall job into subfunctions, assigning each to a part, and tracing how the parts' outputs satisfy the whole's requirements. It grew out of the systems analysis and weapons-systems engineering of the 1950s and 1960s, when the U.S. defense establishment faced problems—missiles, radar networks, command systems—whose performance depended on interactions among many contractors' products. The discipline's early textbooks, such as Arthur David Hall's A Methodology for Systems Engineering (1962), treated the system as a hierarchy of functions to be allocated to hardware, software, and people.

The idea's power is that it separates what from how: a function like "provide electrical power" can be allocated to a battery, a generator, or a fuel cell, and the choice deferred until trade studies are done. Its weakness is that pure functional trees say little about interfaces and nothing about how the system behaves over time. The allocation step—mapping functions onto physical elements and recording the mapping in a requirements traceability matrix—became standard practice, and remains the backbone of most architecture work today. But by the 1970s practitioners had noticed that decomposition alone produced designs that were locally sensible and globally fragile, because the interactions between allocated parts were where systems actually failed.

Structured Analysis and Design: Making the Description Formal

The response was to make the description itself a formal artifact. In software and systems practice from the late 1960s through the 1980s, "structured" methods appeared: structured analysis, which modeled a system as data flows and processes; structured design, which organized those processes into a call hierarchy; and structured programming at the code level. The best-known systems variant is the Structured Analysis and Design Technique (SADT), developed by Douglas Ross at SofTech in the late 1960s and published in the 1970s. SADT modeled a system as a hierarchy of boxes—activities or data—connected by arrows for inputs, controls, outputs, and mechanisms, with each box decomposable into a more detailed diagram2. Its discipline of "one diagram, one viewpoint, checked for consistency against its parent" was an early statement of a principle that would later become central: an architecture is a set of coordinated partial descriptions, not a single picture.

These methods mattered because they gave teams a shared notation and a review discipline. A SADT model could be walked through with a customer and checked for completeness; a data-flow diagram could be handed to a programmer. What they could not do well was handle concurrency, physical constraints, and the sheer heterogeneity of large systems, where software, hydraulics, and operators all interact. That gap pushed the field toward richer, multi-view descriptions.

Frameworks: Architecture as a Managed Discipline

The 1980s and 1990s saw architecture become an explicit management concern, especially in defense and enterprise computing. In the United States, the Department of Defense's C4ISR Architecture Framework (1996) and its successor, the DoD Architecture Framework (DoDAF), defined standard "views"—operational, systems, and technical—that programs had to produce. The UK Ministry of Defence developed its own framework (MODAF) in the mid-2000s, and The Open Group's TOGAF, first published in 1995, did the same for enterprise information systems. These frameworks shared a logic: if every program describes its system in the same view types, architectures can be compared, integrated, and governed across a portfolio.

The frameworks were powerful and widely adopted, but they attracted criticism for producing documents rather than understanding—"wallpaper," in the field's rueful term—and for being heavy to tailor. Their lasting contribution was the idea of the architecture description as a governed artifact with defined content, and the recognition that architecture spans not just a system but an enterprise of systems.

Viewpoints: The Conceptual Core

Running alongside the frameworks was a deeper theoretical development: viewpoint-based architecture description. The insight, articulated most influentially by Philippe Kruchten's "4+1" view model of software architecture (1995), is that no single representation can serve all stakeholders. Kruchten proposed describing a system through several concurrent views—logical, process, development, physical, plus scenarios that tie them together—each addressing different concerns. The IEEE 1471 standard (2000, later revised as ISO/IEC 42010) generalized this: an architecture description consists of views, each conforming to a viewpoint that defines its stakeholders, concerns, and notations. This gave the field a vocabulary—stakeholder, concern, viewpoint, view—that made "which description for which audience" a design question rather than an accident.

The practical consequence is visible in any modern architecture review: a power budget, an interface control document, a sequence diagram, and an operational concept are all legitimate architecture views, and the architect's job includes choosing which to produce and keeping them consistent.

Tradespace: Architecture as Search

If viewpoints define what an architecture description contains, tradespace exploration defines how the architect chooses among candidates. The idea is to represent the design space as a set of alternatives scored against multiple objectives—cost, performance, risk, schedule—and to search it rather than commit early to one concept. Early quantitative work in this vein appeared in aerospace and defense studies from the 1960s onward, but the approach crystallized in the 2000s around the work of Olivier de Weck and colleagues at MIT, who formalized tradespace exploration with Pareto fronts and change-propagation analysis. The concrete case is a satellite or an aircraft family: rather than picking a point design, the team generates hundreds of feasible architectures, plots them against objectives, and examines the Pareto-optimal set—the alternatives no other beats on every objective. This reframes architecture from "decide and defend" to "map and select," and it made explicit that many architecture decisions are really portfolio decisions under uncertainty.

Object-Process Methodology: A Unified Model

A distinctive strand sought to unify the functional and object views into a single model. Object-Process Methodology (OPM), developed by Dov Dori at the Technion from the early 1990s and standardized by ISO in 2015 (ISO 19450), represents a system with just two kinds of things: objects (what exists) and processes (what happens), linked by states and transformations3. A single diagram type can show that a satellite's battery (object) is charged by a solar array process, with the battery's state changing from depleted to charged. OPM's claim is that function and structure need not be separate views at all; one ontology can carry both. It remains a minority approach but is a clean statement of a recurring question: how many kinds of description does an architecture really need?

Model-Based Systems Engineering: Architecture in the Model

The most recent turn is model-based systems engineering (MBSE): doing architecture in a formal, shared model rather than in documents4. The vision was articulated in INCOSE's MBSE initiative from 2007, and its practical vehicle became the Systems Modeling Language (SysML), adopted by the Object Management Group in 2006. SysML lets an architect define blocks, ports, interfaces, requirements, and parametric constraints in one repository, so that a change to an interface propagates to every view that references it. The concrete difference from document-based practice is traceability by construction: a requirement is linked to the function that satisfies it and the block that implements it, and the links are queryable4.

MBSE descends directly from the earlier strands—functional decomposition appears as activity and block hierarchies, viewpoints as diagram types, tradespaces as parametric models—but it changes the economics of keeping descriptions consistent. Its open questions are the field's open questions: how to keep models and the real system synchronized across a long life (the "digital thread"), how to make model-based architecture usable by suppliers and small teams, and how to validate that a model's abstractions actually predict the behavior of the built system. The frameworks, viewpoints, and tradespace methods of the past century have not been replaced; they have been absorbed into models, where the same old question—what must a description contain to let many people build one coherent whole—is being answered again.

References

  1. Systems architecture (Overview), Wikipedia
  2. Structured analysis and design technique, Wikipedia
  3. Object Process Methodology (introduction, History), Wikipedia
  4. Model-based systems engineering, Wikipedia

The frameworks of Systems Architecture

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1955-Present
  2. 1968-1990

    Structured analysis and design technique

    How can a system description be made formal and reviewable?

    Fly to its tower in Nousfarer

  3. 1993-Present

    Object-Process Methodology

    Can function and structure share one model?

    Fly to its tower in Nousfarer

  4. 1995-Present

    Architecture Frameworks

    How should programs describe systems so they can be compared?

    Fly to its tower in Nousfarer

  5. 1995-Present

    View model

    Which description serves which stakeholder?

    Fly to its tower in Nousfarer

  6. 2000-Present

    Tradespace Exploration

    How should an architect choose among candidate designs?

    Fly to its tower in Nousfarer

  7. 2006-Present

    Model-Based Systems Engineering

    How can architecture live in one shared model?

    Fly to its tower in Nousfarer

How the ideas connect

Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.

Functional Decomposition and Allocati…Structured analysis and design techni…Object-Process MethodologyArchitecture FrameworksView modelTradespace ExplorationModel-Based Systems Engineering

Beyond the field

Where Systems Architecture's ideas came from in other fields, and what they led to there: the strongest 12 of 36 links.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

Systems Architecture is a planet in Nousfarer

Its city has a tower for each of these 7 frameworks. Land, walk in, and climb one concept at a time.

Land on Systems Architecture

Related fields

Fields its ideas are linked to

More in Systems Engineering

See where Systems Architecture sits on the Map of Human Knowledge