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

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

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

  1. Systems analysis (introduction, Information technology), Wikipedia
  2. Structured analysis (History), Wikipedia
  3. Structured analysis and design technique (History), Wikipedia
  4. Data modeling, Wikipedia
  5. Entity–relationship model, Wikipedia
  6. Software prototyping, Wikipedia
  7. Object-oriented analysis and design, Wikipedia
  8. Object-oriented programming, Wikipedia
  9. Unified Modeling Language, Wikipedia
  10. Use case (History, introduction), Wikipedia
  11. Business process modeling, Wikipedia
  12. Design science (methodology), Wikipedia
  13. 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.

  1. 1960-1990

    Systems Development Life Cycle

    What phases should a system pass through from idea to maintenance?

    Fly to its tower in Nousfarer

  2. 1970-1995

    Sociotechnical system

    How can technical and social needs be optimized together in a work system?

    Fly to its tower in Nousfarer

  3. 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.
    1. 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.
    2. 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.
    3. 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.
    4. Data Dictionary — A central repository of data definitions, describing each data flow and data store in the DFDs, including its composition (e.g., Customer Order=CustomerOrder = Customer ID + Order Date + Item List) and any relevant meaning.
    5. 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.
    6. 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.
    7. 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.
    8. 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.
    9. 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.
    10. 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.
    11. 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.
    12. 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.
    13. 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

    Fly to its tower in Nousfarer

  4. 1975-Present

    Participatory Design

    How can the people affected by a system help design it?

    Fly to its tower in Nousfarer

  5. 1976-Present

    Data Modeling

    How should information about things and their relations be structured?

    Fly to its tower in Nousfarer

  6. 1980-Present

    Software prototyping

    How can users react to a system before it is fully built?

    Fly to its tower in Nousfarer

  7. 1981-Present

    Soft Systems Methodology

    How can stakeholders negotiate when they disagree about the problem?

    Fly to its tower in Nousfarer

  8. 1990-Present

    Business Process Modeling

    How should end-to-end flows of work be described and redesigned?

    Fly to its tower in Nousfarer

  9. 1990-Present

    Object-Oriented Analysis and Design

    How should software be modeled as interacting objects?

    Fly to its tower in Nousfarer

  10. 1992-Present

    Packaged-System Selection and Configuration

    How should an organization choose and adapt a bought system?

    Fly to its tower in Nousfarer

  11. 2001-Present

    Agile software development

    How can software be built while requirements keep changing?

    Fly to its tower in Nousfarer

  12. 2004-Present

    Design science

    Can building and testing artifacts produce valid knowledge?

    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.

Systems Development Life CycleSociotechnical systemStructured analysisParticipatory DesignData ModelingSoftware prototypingSoft Systems MethodologyBusiness Process ModelingObject-Oriented Analysis and DesignPackaged-System Selection and Configu…Agile software developmentDesign science

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.

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 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 Design

Related fields

Fields its ideas are linked to

More in Information Systems

See where Systems Analysis And Design sits on the Map of Human Knowledge