- Atlas
- Business, Management & Finance
- Systems Analysis And Design
Systems Analysis And Design
Systems analysis and design is the discipline of deciding what an information system should do and how it should be built before and while it is built.
12 frameworks, from 1960 to today · Information Systems · Business, Management & Finance
- Systems Development Life Cycle 1960-1990
- Sociotechnical system 1970-1995
- Structured analysis 1974-1995
- Participatory Design 1975-Present
- Data Modeling 1976-Present
- Software prototyping 1980-Present
- Soft Systems Methodology 1981-Present
- Business Process Modeling 1990-Present
- Object-Oriented Analysis and Design 1990-Present
- Packaged-System Selection and Configuration 1992-Present
- Agile software development 2001-Present
- Design science 2004-Present
Overview
Systems analysis and design is the discipline of deciding what an information system should do and how it should be built before and while it is built1. Its practitioners—analysts, designers, architects, and the users they work with—produce specifications, models, prototypes, and plans: representations of a future system that let people argue about it, cost it, and construct it. The stakes are practical. Large systems fail often, and the way a system is analyzed and designed—who is consulted, what is modeled, how change is managed—shapes whether it succeeds. The field's history is a sequence of attempts to make that work more reliable, each responding to the failures of the last.
Programming for business and the first methods (1950s–1960s)
The earliest business computing was bespoke. Programmers wrote code directly for accounting, payroll, and inventory tasks, and "analysis" meant little more than understanding the clerical procedure being automated. As computers spread through organizations in the late 1950s and 1960s, the gap between what managers wanted and what programmers delivered became a recognized problem. Systems were built that worked technically but solved the wrong problem, or that no one could maintain once the original programmer left.
The response was method. The systems development life cycle (SDLC)—a phased sequence of feasibility study, requirements analysis, design, construction, testing, and maintenance—gave projects a structure and a paper trail. Its intellectual home was often the data-processing department, and its guiding metaphor was engineering: define the problem, specify the solution, then build it. This "waterfall" logic, though the term came later, dominated practice for decades and still underlies much formal procurement.
Structured analysis and design (1970s)
The 1970s brought a family of techniques that made the specification itself rigorous2. Structured analysis represented a system as a hierarchy of processes, with data flowing between them, drawn in data flow diagrams—boxes for processes, arrows for data, stores for files3. Structured design then turned those process models into a module structure with controlled coupling and cohesion. The best-known statement is Tom DeMarco's Structured Analysis and System Specification (1978); Ed Yourdon and Larry Constantine's work on structured design dates from the mid-1970s23. The appeal was decomposition: break a large, incomprehensible system into small, comprehensible parts, each with a clear job.
Alongside this, data modeling gave the field a way to describe information independently of process4. The entity-relationship model, introduced by Peter Chen in 1976, depicted things (entities), their attributes, and how they relate—a customer has many orders5. This let analysts design databases and, crucially, argue about data structure separately from program logic. Data modeling became the backbone of the database world and a permanent part of the analyst's toolkit.
The sociotechnical critique and user participation (1970s–1980s)
A parallel tradition insisted that systems are not just technical artifacts. Sociotechnical design, rooted in the Tavistock Institute's studies of British coal mining in the 1950s, held that work systems must jointly optimize the technical and the social—that a technically elegant system which deskills or alienates its users is a failure. Enid Mumford's ETHICS method (Effective Technical and Human Implementation of Computer-based Systems), developed at Manchester in the 1970s and published in book form in 1983, made user participation a design procedure: workers helped design their own systems, with explicit attention to job satisfaction.
Participatory design pushed this further, most visibly in Scandinavia. The "collective resource" approach of Kristen Nygaard and others at the Norwegian Computing Center in the 1970s, and the DEMOS project in Sweden, treated workers and their unions as parties with a right to shape the technology that would reshape their jobs. The methods were concrete—mock-ups, workshops, and simulations in which users handled a proposed system before it existed. The claim was both ethical and practical: people support what they help build, and they know their work better than any analyst.
Soft systems and the recognition of messiness (1980s)
By the 1980s, many analysts had concluded that structured methods assumed too much. They worked when the problem was well defined; they stumbled when stakeholders disagreed about what the problem even was. Peter Checkland, at Lancaster University, developed soft systems methodology (SSM) from action research in the 1970s and 1980s, published as Systems Thinking, Systems Practice (1981). SSM does not model the system to be built; it models human activity systems—purposeful worldviews—as a way to surface disagreement and negotiate feasible change. Its "rich picture" and "CATWOE" analysis (customers, actors, transformation, worldview, owner, environment) are tools for structuring debate, not for specifying code. SSM's supporters found it convincing precisely because it addressed the political, contested reality that hard methods ignored.
Prototyping, iteration, and the turn to objects (1980s–1990s)
The waterfall's weakness—that requirements are frozen before anyone has seen the system—invited a countermovement. Prototyping built a rough version early so users could react to something concrete6. Barry Boehm's spiral model (1988) formalized iterative development around repeated risk analysis, and rapid application development (RAD) in the early 1990s pushed short cycles and heavy user involvement. The insight was that requirements are discovered, not elicited: people recognize what they want when they see it.
Meanwhile, object-oriented analysis and design reorganized the field's basic units7. Instead of separating data and process, objects bundle both—a "customer" carries its data and the operations on it8. Grady Booch, Ivar Jacobson, and James Rumbaugh merged their competing notations into the Unified Modeling Language (UML) in the mid-1990s, and the Unified Process gave object-oriented projects an iterative, use-case-driven structure910. Use cases—scenarios of how an actor interacts with the system—became a standard way to capture requirements110.
Processes, packages, and the design-science turn (1990s–2000s)
Two other developments reshaped practice. First, business process modeling shifted attention from individual systems to the flows of work they support11. The 1990s business process reengineering wave, and later notations such as BPMN (Business Process Model and Notation, standardized in 2004–2006), gave analysts a vocabulary for describing and redesigning end-to-end processes before automating them.
Second, the rise of enterprise resource planning (ERP) packages in the 1990s changed what "design" meant. Instead of building from scratch, organizations bought large integrated systems and configured them. Packaged-system selection and configuration became a distinct skill: evaluating vendors, mapping organizational processes onto the package's built-in logic, and managing the compromises that followed. The analyst's job shifted from invention to fit—and to recognizing when the package, not the organization, would dictate how work was done.
Within academia, design science research argued that building and evaluating artifacts—models, methods, systems—is itself a legitimate mode of producing knowledge, not merely applied engineering12. Codified in information systems by the early 2000s (notably through work by Alan Hevner and colleagues in 2004), it gave the field a research identity distinct from behavioral study of existing systems.
Agile and the present (2001–)
In 2001, seventeen practitioners published the Agile Manifesto, valuing working software, customer collaboration, and response to change over comprehensive documentation and contract negotiation13. Agile methods—Scrum, Extreme Programming—grew from earlier iterative practices and from frustration with heavyweight processes13. For analysis and design, agile meant requirements as a living backlog, design emerging incrementally, and the analyst embedded in a team rather than producing a specification handed over a wall. The tension between agile's embrace of change and the need for architectural foresight remains unresolved and actively debated.
Today the field's main approaches coexist rather than replace one another. Structured and object-oriented modeling persist where formal contracts or regulated systems demand them; UML and BPMN remain standard notations; sociotechnical and participatory commitments survive in user-centered and co-design practice; soft systems thinking informs problem structuring in complex organizational settings; and agile dominates much commercial development. The open questions are familiar in new dress: how to design for systems that learn and adapt, how to keep human judgment and participation central when systems are assembled from packages and cloud services, and how to reconcile speed with the durability that good design has always required.
References
- Systems analysis (introduction, Information technology), Wikipedia
- Structured analysis (History), Wikipedia
- Structured analysis and design technique (History), Wikipedia
- Data modeling, Wikipedia
- Entity–relationship model, Wikipedia
- Software prototyping, Wikipedia
- Object-oriented analysis and design, Wikipedia
- Object-oriented programming, Wikipedia
- Unified Modeling Language, Wikipedia
- Use case (History, introduction), Wikipedia
- Business process modeling, Wikipedia
- Design science (methodology), Wikipedia
- Agile software development (introduction, History), Wikipedia
The frameworks of Systems Analysis And Design
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1960-1990
Systems Development Life Cycle
What phases should a system pass through from idea to maintenance?
- 1970-1995
Sociotechnical system
How can technical and social needs be optimized together in a work system?
- 1974-1995
Structured analysis
How can a system's processes and data flows be modeled rigorously?
About Structured analysis
In the 1970s, as organizations began to rely on computer-based systems, development was often ad hoc. Programs were written without systematic planning, leading to systems that were difficult to maintain, expensive to change, and prone to failure. Structured Analysis and Design emerged as the first major response, bringing engineering discipline to software projects. Its core idea was to decompose a system into hierarchical functions, and it became the dominant methodological school for building large corporate and government information systems throughout the 1970s and 1980s.The curriculum for a first course in Structured Analysis and Design centers on a sequence of concepts that guide the analyst from understanding what a system should do to specifying how it will be built. The approach begins by modeling the current environment and the desired system using a set of graphical and textual tools.- Data Flow Diagrams (DFDs) — These diagrams show the flow of data through a system, depicting external entities, processes, data stores, and data flows. They are used to model both the current physical system and the logical system the new system will implement. A DFD is built by iterative decomposition, starting with a context diagram (level 0) that shows the system as a single process, then expanding into more detailed levels.
- Context Diagram — This top-level DFD shows the entire system as a single process, its external entities (sources and sinks of data), and the data flows between them. It establishes the system boundary.
- Leveled DFDs — The context diagram is decomposed into a hierarchy of DFDs at increasing levels of detail (level 1, level 2, etc.), each representing a subprocess of the parent. This hierarchical refinement provides a controlled way to manage complexity.
- Data Dictionary — A central repository of data definitions, describing each data flow and data store in the DFDs, including its composition (e.g., Customer ID + Order Date + Item List) and any relevant meaning.
- Process Specification (Mini-Spec) — A precise description of the logic inside the lowest-level process bubbles, often written in structured English (a restricted subset of natural language), decision tables, or decision trees. The mini-spec defines the transformation rules for the process.
- Entity-Relationship Diagram (ERD) — A model of the data structure, showing entities (things about which data is stored), attributes, and the relationships between entities. The ERD complements the DFD by modeling the static data structure.
- Structure Chart — The primary tool for structured design. It shows the hierarchical organization of modules, the data couples and control flags passed between them, and the sequencing of calls (e.g., sequence, selection, iteration). The structure chart is derived from the DFDs through a process called transform analysis or transaction analysis.
- Structured English — A restricted syntax for writing process specifications, using a limited vocabulary and simple imperative statements (e.g., IF-THEN-ELSE, DO WHILE). It avoids the ambiguity of natural language while remaining readable by non-programmers.
- Decision Table / Decision Tree — Complementary tools for specifying complex logic, especially when multiple conditions interact. Decision tables present a matrix of conditions and actions; decision trees provide a branching representation.
- Transform Analysis — A structured design strategy that identifies the flow of data as it enters the system (afferent stream), is processed (transform center), and leaves (efferent stream). The structure chart is then derived from the DFD by mapping these streams to a hierarchical module structure.
- Transaction Analysis — A design strategy for systems where the primary flow is driven by different transaction types. The DFD is partitioned around transaction centers, and a structure chart is built around a central controller that dispatches to handle each transaction type.
- Coupling and Cohesion — Two metrics that guide modular design. Coupling measures the strength of interconnection between modules (low coupling is desirable); cohesion measures the functional strength within a single module (high cohesion is desirable). The goal is high cohesion and low coupling.
- System Flowchart — A diagram used to show the manual and automated steps, the media and forms involved, and the overall sequence of operations in a system. It is used more for documenting the physical environment, often replaced by DFDs for logical modeling.
The intellectual history of Structured Analysis and Design begins in the late 1960s and early 1970s, driven by the 'software crisis'—the recognition that large software projects were failing due to lack of discipline. The key framework-building figures and works are:- Larry Constantine (with Edward Yourdon, 1975, Structured Design) articulated the principles of modularity, coupling, and cohesion, and developed the structure chart and the transform/transaction analysis strategies. This work defined the 'Design' part of the school.
- Tom DeMarco (1978, Structured Analysis and System Specification) codified the modern data flow diagram, the leveled DFD set, the data dictionary, and the process specification. His book became the seminal text for the 'Analysis' side.
- Chris Gane and Trish Sarson (1979, Structured Systems Analysis: Tools and Techniques) offered another influential variant of DFD notation and methodology, particularly popular in business environments.
- Predecessors working outside the local framework window include the advocates of structured programming (Edsger Dijkstra, 1968) and stepwise refinement (Niklaus Wirth, 1971), which provided the programming-level rationale for top-down decomposition. The Database Task Group (of CODASYL) and early entity-relationship modeling by Peter Chen (1976) also provided precursor work for the ERD.
- A later codifier was Yourdon Inc. and the widely used Yourdon Structured Method, which further standardized the notation, especially in the 1980s. SSADM (Structured Systems Analysis and Design Method), developed by the UK government in the 1980s, is a fully codified methodology that grew directly from these origins.
- The successor frameworks that absorbed or transformed this school include Object-Oriented Analysis and Design (OOAD) (around 1990 onward), which replaced functional decomposition with object decomposition, and the Unified Modeling Language (UML) (1997), which subsumed many structured notations into a single conceptual modeling framework. The Socio-Technical Systems Perspective, while overlapping in time, coexisted as a parallel tradition that criticized the purely technical focus of the structured era. Agile Methodologies (from 1999) rejected the heavy documentation and rigid sequence of structured approaches.
Key insights from this framework include the understanding that system decomposition, when done through functional hierarchies, brings predictability and auditing to the development process. It established the crucial distinction between what a system does (analysis) and how it is built (design), and it created the enduring vocabulary of diagrams for communicating system requirements. A common pitfall is to mistake the diagrams (DFDs, structure charts) for the methodology itself—the real value lies in the disciplined, top-down, hierarchical thinking that the tools enforce, not in the symbols on the page.The 14 concepts its tower teaches
- Cohesion
- Context Diagram
- Coupling
- Data Dictionary
- Data Flow Diagrams (DFDs)
- Decision Table / Decision Tree
- Entity-Relationship Diagram (ERD)
- Leveled DFDs
- Process Specification (Mini-Spec)
- Structure Chart
- Structured English
- System Flowchart
- Transaction Analysis
- Transform Analysis
- 1975-Present
Participatory Design
How can the people affected by a system help design it?
- 1976-Present
Data Modeling
How should information about things and their relations be structured?
- 1980-Present
Software prototyping
How can users react to a system before it is fully built?
- 1981-Present
Soft Systems Methodology
How can stakeholders negotiate when they disagree about the problem?
- 1990-Present
Business Process Modeling
How should end-to-end flows of work be described and redesigned?
- 1990-Present
Object-Oriented Analysis and Design
How should software be modeled as interacting objects?
- 1992-Present
Packaged-System Selection and Configuration
How should an organization choose and adapt a bought system?
- 2001-Present
Agile software development
How can software be built while requirements keep changing?
- 2004-Present
Design science
Can building and testing artifacts produce valid knowledge?
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.
Structured analysis grew out of Systems Development Life Cycle
Structured analysis refined the SDLC's requirements-analysis phase into a rigorous modeling technique, replacing prose specifications with data flow diagrams. DeMarco, Yourdon and Constantine built directly on the life-cycle framework's assumption that analysis precedes design.
Carried by Tom DeMarco; Ed Yourdon; Larry Constantine.
Software prototyping reacted against Systems Development Life Cycle
Prototyping arose as a response to the waterfall's practice of freezing requirements before any system existed. Boehm's spiral model (1988) explicitly reworked the life cycle into iterative cycles with repeated risk analysis.
Carried by Barry Boehm.
Agile software development reacted against Systems Development Life Cycle
Agile defined itself against the heavyweight, documentation-driven life cycle, valuing working software and response to change over comprehensive specification. The Manifesto's authors were rejecting the phased, contract-bound model they had practiced.
Carried by Agile Manifesto (2001).
Participatory Design grew out of Sociotechnical system
Participatory design extended the sociotechnical insistence on joint optimization of technical and social systems into a demand that workers themselves shape the technology. The Scandinavian collective-resource projects drew on Tavistock-rooted ideas about work systems and deskilling.
Carried by Kristen Nygaard; Enid Mumford.
Soft Systems Methodology reacted against Structured analysis
Soft systems methodology was Checkland's answer to the failure of structured, hard-systems analysis when stakeholders disagreed about the problem. SSM models human activity systems instead of data flows precisely because structured analysis assumed a definable objective.
Carried by Peter Checkland; Systems Thinking, Systems Practice (1981).
Object-Oriented Analysis and Design replaced Structured analysis
Object-oriented analysis and design replaced the process-and-data-flow decomposition of structured analysis with objects that bundle data and behavior. Booch, Rumbaugh and Jacobson's UML consolidated the notation that displaced data flow diagrams in practice.
Carried by Grady Booch; Ivar Jacobson; James Rumbaugh.
Object-Oriented Analysis and Design influenced by Data Modeling
Object-oriented design absorbed entity-relationship modeling's separation of data structure, recasting entities as classes with attributes and relationships. Chen's ER model gave analysts the vocabulary of entities and relations that OO class modeling built upon.
Carried by Peter Chen.
Agile software development grew out of Software prototyping
Agile methods grew out of iterative and prototyping practice, including Boehm's spiral model and rapid application development, which had already established short cycles and user feedback. The Manifesto's signatories carried that iterative inheritance into Scrum and Extreme Programming.
Carried by Barry Boehm; Agile Manifesto (2001).
Object-Oriented Analysis and Design influenced by Software prototyping
The Unified Process that accompanied object-oriented design adopted iterative, use-case-driven development, carrying forward the prototyping insight that requirements are discovered through early versions. Jacobson's use cases and the UP's cycles drew on the iterative turn of the 1980s.
Carried by Ivar Jacobson.
Packaged-System Selection and Configuration influenced by Business Process Modeling
Packaged-system selection and configuration required mapping organizational processes onto the package's built-in logic, a task that drew on the process-modeling vocabulary developed for reengineering. Analysts used process models to compare what the organization did with what the ERP package assumed.
Agile software development influenced by Object-Oriented Analysis and Design
Agile practice absorbed use cases and incremental object design from the object-oriented tradition, with Extreme Programming and Scrum embedding lightweight modeling in short iterations. The Unified Process's iterative structure was a direct precursor to agile cycles.
Carried by Ivar Jacobson.
Beyond the field
Where Systems Analysis And Design's ideas came from in other fields, and what they led to there: the strongest 12 of 68 links.
Systems Development Life Cycle influenced by Systems Engineering in Industrial Engineering
Early SDLC formulations drew on systems engineering practice, especially the waterfall-style sequence of requirements, design, implementation and test carried into information systems work in the 1960s. The staged life-cycle model is a direct transfer of the engineering project life cycle to software.
Carried by Systems Engineering.
Systems Development Life Cycle led to Waterfall Model in Systems Lifecycle
The waterfall model grew directly out of the systems development life cycle taught in systems analysis and design, adopting its ordered analysis-design-implementation phases as a strict sequence.
Systems Development Life Cycle led to Waterfall Model in Software Engineering
The waterfall model for software descended from the systems development life cycle used in business systems analysis, adopting its phases of requirements, analysis, design, implementation and maintenance in strict sequence.
Carried by Winston W. Royce.
Systems Development Life Cycle led to Waterfall Model in Software Process Models
The waterfall model is the SDLC's sequential phases made explicit and prescriptive, with feedback loops added. Royce's 1970 paper formalised the phase sequence that the SDLC literature had already established.
Carried by Winston W. Royce; Managing the Development of Large Software Systems (1970).
Sociotechnical system led to ETHICS in Sociotechnical Systems
ETHICS was built directly on the sociotechnical systems approach to systems analysis and design, adapting its joint optimization and participation principles to information systems.
Carried by Enid Mumford.
Structured analysis influenced Object-Oriented Analysis in Requirements Engineering
Object-oriented analysis methods such as Coad and Yourdon's and Rumbaugh's OMT were built as successors to structured analysis, reusing its data-flow and functional decomposition views while wrapping them in object concepts. The OOA literature explicitly contrasts its models with the data flow diagrams and data dictionaries of structured analysis.
Carried by Peter Coad; Edward Yourdon; James Rumbaugh.
Structured analysis influenced Structured systems analysis and design method in Requirements Engineering
SSADM incorporated the data-flow and data-dictionary techniques of structured analysis as its central analysis notation. The UK method standardised those techniques for public-sector information systems development.
Participatory Design led to Participatory algorithmic design in Participatory Design
Participatory algorithmic design extends the systems-analysis-and-design strand of participatory design, which grew from Scandinavian trade-union and workplace democracy projects. The later field applies that strand's user-involvement and power-sharing concerns to algorithmic decision systems.
Participatory Design influenced by Scandinavian system development and democracy in Participatory Design
Scandinavian system development and democracy projects, notably the DEMOS and UTOPIA projects, directly created the methods and commitments of participatory design in computing. Participatory design emerged as the continuation of that Scandinavian workplace-democracy programme.
Carried by DEMOS project; UTOPIA project.
Participatory Design influenced by Sociotechnical system in Participatory Design
Sociotechnical systems theory, with its joint optimisation and worker-participation commitments, is the direct intellectual source of participatory design in information systems. The Scandinavian projects that founded participatory design drew explicitly on that theory.
Carried by Eric Trist; Norwegian Industrial Democracy Programme.
Object-Oriented Analysis and Design influenced by Object-oriented programming in Programming Paradigms
The object concept originated in the 1960s with Simula's class-based simulation language and Kristensen and Dahl's work, which established objects, classes and inheritance. These programming-language ideas were the direct source of the object model that OO analysis and design methods later formalised.
Carried by Simula 67 (1967); Ole-Johan Dahl; Kristen Nygaard.
Object-Oriented Analysis and Design influenced by Object-oriented programming in Software Engineering
Object-oriented analysis and design methods were built to carry the object model of OO programming languages into the analysis and design phases. The encapsulation, inheritance and message-passing concepts of Smalltalk and C++ were taken up by Booch, Rumbaugh and Jacobson as the vocabulary of their design methods.
Carried by Grady Booch; James Rumbaugh; Ivar Jacobson.

Systems Analysis And Design is a planet in Nousfarer
Its city has a tower for each of these 12 frameworks. Land, walk in, and climb one concept at a time.
Land on Systems Analysis And DesignRelated fields
Fields its ideas are linked to
- Requirements Engineering 8 links
- Model Based Systems Engineering 5 links
- Systems Architecture 4 links
- Data Modeling 3 links
- Participatory Design 3 links
- Enterprise Systems 3 links
- Sociotechnical Systems 3 links
- Software Architecture 3 links
- Software Engineering 3 links
- Software Process Models 3 links
- Systems Engineering 3 links
- Information Systems 2 links
More in Information Systems
- Business Analytics
- Decision Support Systems
- Digital Strategy
- Electronic Commerce
- Enterprise Architecture
- Enterprise Systems
- Information Systems
- It Governance
- Platform Strategy
- Sociotechnical Systems
See where Systems Analysis And Design sits on the Map of Human Knowledge