Study guide

9.1 Scope Modeling: Context Diagrams, Ecosystem Maps & Feature Breakdowns

PMI Professional in Business Analysis PMI-PBA

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Introduction, Exam Logistics & Business Analysis Framework

1.1 PMI-PBA Exam Format, Scoring, Logistics & Eligibility 1.2 Business Analyst vs Project Manager: Roles, Boundaries & Standards 1.3 Business Analysis Across Predictive, Adaptive & Hybrid Lifecycles

2 Chapter 2: Needs Assessment — Problem Framing & Opportunity Analysis

2.1 Defining Business Problems, Opportunities & Scope Statements 2.2 Root Cause Analysis: 5 Whys, Fishbone & Interrelationship Digraphs 2.3 Assessing Current Capabilities, Operational Constraints & Organizational Maturity

3 Chapter 3: Needs Assessment — Future State & Feasibility Analysis

3.1 Defining the Desired Future State & Product Scope Boundaries 3.2 Gap Analysis: Capability Matrices, Risk of Inaction & Transition States 3.3 Solution Option Evaluation: Feasibility Studies & Make/Buy/COTS Tradeoffs

4 Chapter 4: Needs Assessment — Business Case, Valuation & Stakeholder Values

4.1 Financial Valuation & Metrics: ROI, NPV, IRR, Payback & Cost-Benefit Analysis 4.2 Developing the Business Case & Aligning SMART Project Goals 4.3 Identifying Stakeholders & Establishing Stakeholder Values Baseline

5 Chapter 5: Planning — BA Approach & Context Framing

5.1 Reviewing Business Case, Project Charter & Context Framing 5.2 Establishing the Business Analysis Approach & Tailoring Strategy 5.3 Business Analysis Work Breakdown, Scheduling & Effort Estimation

6 Chapter 6: Planning — Stakeholder Engagement & Communication

6.1 Stakeholder Analysis: Power/Interest Grid, Salience Model & Onion Diagrams 6.2 Planning Stakeholder Communication, Engagement & Distributed Collaboration 6.3 Managing Stakeholder Expectations, Alignment & Conflict Resolution Pathways

7 Chapter 7: Planning — Governance, Traceability & Change Control

7.1 Developing the Requirements Management Plan (RMP) 7.2 Defining Requirements Traceability Strategy & Hierarchy 7.3 Defining Requirements Change Control Protocols & CCB Workflow 7.4 Document Control, Baselining & Defining Business Metrics/Acceptance Criteria

8 Chapter 8: Analysis — Requirements Elicitation Techniques & Collaboration

8.1 Elicitation Planning, Types & Stakeholder Preparation 8.2 Interactive Elicitation: Interviews, Focus Groups & JAD Workshops 8.3 Observational & User-Centered Elicitation: Job Shadowing & Surveys 8.4 Document Analysis, Interface Analysis & Reverse Engineering

9 Chapter 9: Analysis — Requirements Modeling & Decomposition

9.1 Scope Modeling: Context Diagrams, Ecosystem Maps & Feature Breakdowns 9.2 Process & Workflow Modeling: BPMN, Swimlanes & Value Stream Mapping 9.3 Data & Rules Modeling: ERDs, Data Dictionaries, DFDs & Decision Tables 9.4 Interface Modeling, Wireframing, User Journey Maps & Prototyping

10 Chapter 10: Analysis — Requirements Specification & Acceptance Criteria

10.1 Requirements Taxonomy: Business, Stakeholder, Solution, Transition, Project & Quality 10.2 User Stories, Epics, INVEST Criteria & Acceptance Criteria 10.3 Non-Functional Requirements & Quality Attributes 10.4 Consensus Building, Tradeoff Analysis & Resolving Competing Requirements

11 Chapter 11: Analysis — Verification, Validation, Prioritization & Approval

11.1 Requirements Verification & Quality Characteristics 11.2 Requirements Validation & Strategic Business Alignment 11.3 Requirements Prioritization Techniques: MoSCoW, Kano & WSJF 11.4 Product Risk Analysis & Design Option Evaluation

12 Chapter 12: Traceability & Monitoring — Traceability Matrix & Baselining

12.1 Constructing & Maintaining the Requirements Traceability Matrix (RTM) 12.2 Monitoring Requirements Across Lifecycle Artifacts 12.3 Requirements Baselining, Scope Management & Preventing Creep

13 Chapter 13: Traceability & Monitoring — Lifecycle States & Change Management

13.1 Managing Requirements Status & Lifecycle State Transitions 13.2 Communicating Requirements Status, Visual Dashboards & Burndowns 13.3 Requirements Change Management & Multi-Dimensional Impact Analysis 13.4 Resolving Requirements Conflicts, Defect Triage & Variance Management

14 Chapter 14: Evaluation & Professional Conduct

14.1 Validating Test Evidence & Results Against Acceptance Criteria 14.2 Solution Gap Analysis, Discrepancy Resolution & Workarounds 14.3 Facilitating Stakeholder Sign-Off, Operational Readiness & Transition 14.4 Evaluating Long-Term Solution Performance & Value Realization 14.5 PMI Code of Ethics, Professional Conduct & Continuing Certification (CCR)

9.1 Scope Modeling: Context Diagrams, Ecosystem Maps & Feature Breakdowns

Key Takeaways Explain This Topic AI

Scope models establish definitive system boundaries, operational context, and external interfaces, serving as the foundational defense against project scope creep.

A Data Flow Diagram (DFD) Level 0 Context Diagram represents the entire proposed solution as a single central process bubble (Process 0), surrounded exclusively by external entities and boundary data flows, strictly prohibiting internal data stores or internal sub-processes.

Ecosystem Maps provide an enterprise-wide architectural perspective, visualizing how multiple distinct systems, integration hubs, third-party platforms, and data pipelines interact across organizational boundaries.

Feature Breakdown Structures (FBS) deliver a hierarchical, capability-driven decomposition of product scope—from overarching solution themes down to atomic features—distinguishing product scope from project delivery work (WBS).

Use Case Diagrams model system boundaries, actors, and functional interactions, enforcing rigorous UML distinctions where <<include>> denotes mandatory, unconditional common sub-routines and <<extend>> denotes optional, conditionally triggered extensions.

Last updated: September 2026

9.1 Scope Modeling: Context Diagrams, Ecosystem Maps & Feature Breakdowns

Note

PMI-PBA Examination Alignment : Domain 3 (Analysis) represents the single largest domain on the PMI-PBA examination, accounting for 35% of all scored items (~61–62 questions). Within Domain 3, Tasks 2 and 3 mandate that the business analyst analyze, refine, elaborate, and model requirements using appropriate visual and textual techniques. Scope modeling serves as the primary analytical gateway in this domain. Questions frequently test your ability to select the right scope modeling technique, identify boundary violations in context diagrams, navigate complex multi-system enterprise architectures, and correctly apply UML Use Case dependency semantics.

The Scope Modeling Imperative in Business Analysis

In requirements engineering, the most persistent driver of project failure, budget overruns, and delivery conflict is scope ambiguity . When an enterprise commits capital to a technology or process transformation, business stakeholders often envision expansive, all-encompassing capabilities, while technical architects conceptualize constrained technical components. Without rigorous scope models, these conflicting mental models remain unexposed until testing or deployment, leading to catastrophic scope creep, missed deadlines, and unfulfilled business cases.

Under The PMI Guide to Business Analysis and Business Analysis for Practitioners: A Practice Guide , scope modeling is the deliberate process of visually and structurally defining the boundaries of a proposed solution. It establishes:

What is inside the solution scope (capabilities, automated behaviors, managed data, and direct functions engineered by the project team).

What is outside the solution scope (external users, legacy environments, autonomous partner systems, and upstream/downstream data sources).

The touchpoints and interfaces connecting the two (inbound data, outbound reports, API payloads, and hardware interactions).

Scope models do not attempt to detail how a system executes internal business logic or how a database schema is normalized. Instead, they answer three foundational architectural questions: Where does the solution begin and end? , Who and what interacts with it? , and What critical information traverses its boundaries? +-----------------------------------------------------------------------------------+

  • | The Scope Modeling Hierarchy |
  • +-----------------------------------------------------------------------------------+
  • | 1. Ecosystem Map: Enterprise Landscape & Cross-System Topography |
  • | ↓ |
  • | 2. Context Diagram (DFD Level 0): Solution Boundary, External Entities & Flows |
  • | ↓ |
  • | 3. Use Case Diagram: User/System Goals, Actor Boundaries & Behavioral Extensions |
  • | ↓ |
  • | 4. Feature Breakdown Structure (FBS): Functional Capability Decomposition (L0-L4) |
  • +-----------------------------------------------------------------------------------+
  • Data Flow Diagram Level 0: The System Context Diagram

The Context Diagram —formally designated as a Level 0 Data Flow Diagram (DFD) —is the highest-level scope model in structured analysis. It defines the boundary between the system under development and the environment in which it operates.

Core Construction Conventions and Rules

A standard-compliant Context Diagram adheres to strict mathematical and semantic modeling conventions:

The Single Central Process Bubble (Process 0) :

The entire solution, regardless of its underlying complexity, microservice architecture, or organizational scale, is represented as exactly one central process bubble (a circle in Yourdon/DeMarco notation or a rounded rectangle in Gane & Sarson notation).

It is explicitly numbered 0 (e.g., 0 Global Loan Origination System or 0 Enterprise Claims Engine ).

It encapsulates the totality of the in-scope solution. No internal sub-processes, internal software modules, or internal components may appear at this level.

External Entities (Terminators / Sources / Sinks) :

External entities represent autonomous people, organizational units, legacy systems, or external third-party services that sit outside the direct operational control of the solution .

Visually rendered as solid squares or rectangles.

Entities act as Sources (originators of inbound data flows) or Sinks (consumers of outbound data flows). An entity can serve simultaneously as both a source and a sink.

Critical Rule : The project team cannot alter the internal mechanics of an external entity; the team can only define the contract across the interface.

Boundary Data Flows :

Directional arrows connecting external entities to the central Process 0 bubble.

Each arrow must be labeled with a concise, descriptive noun or noun phrase representing the physical or electronic packet of information traversing the boundary (e.g., Loan Application Payload , Credit Score Response , Compliance Audit Feed ).

Directionality reflects the movement of information: inbound arrows denote inputs required by the solution; outbound arrows denote outputs generated by the solution.

The Cardinal Rule: Strict Prohibition of Data Stores at Level 0 :

On the PMI-PBA examination, a common trap involves presenting a Context Diagram that includes a data store (e.g., D1 Customer Database or D2 Ledger Table ).

Internal data stores are strictly prohibited at Level 0. Why? A data store represents data at rest inside the system. Exposing an internal data store on a Context Diagram violates encapsulation and reveals internal architectural implementation rather than external scope boundaries.

The Single Exception : If a database is entirely owned, hosted, and governed by an external third-party organization (such as an external national credit bureau database), it is modeled as an External Entity (Terminator) , never as an internal open-ended DFD data store symbol. [ External Entity: Borrower ] [ External Entity: Credit Bureau ]

  • │ │
  • Application │ Credit Risk │
  • Payload │ Score │ Inbound
  • (Inbound) ▼ ▼
  • ┌─────────────────────────────────────────────────────┐
  • │ │
  • │ 0 Global Lending Platform │
  • │ (Solution Scope) │
  • │ │
  • └─────────────────────────────────────────────────────┘
  • │ ▲
  • Origination │ Funding │ Payment
  • Notice │ Transaction │ Confirmation
  • (Outbound) ▼ │ (Inbound)
  • [ External Entity: Underwriting ] [ External Entity: Core Banking ]
  • Decomposing Level 0 into Level 1 DFDs

The Context Diagram serves as the parent of the entire DFD decomposition hierarchy. When the business analyst transitions from high-level scope modeling to functional decomposition, Process 0 is decomposed into a Level 1 DFD :

Process 0 explodes into 3 to 7 primary functional sub-processes (e.g., 1.0 Receive Application , 2.0 Assess Credit Risk , 3.0 Adjudicate Terms , 4.0 Disburse Funds ).

Internal data stores ( D1 Applications , D2 Credit Profiles ) appear for the first time at Level 1, positioned between the internal sub-processes.

Balancing Rule (Conservation of Data) : Every external entity and boundary data flow entering or exiting Process 0 on the Context Diagram must be preserved exactly on the Level 1 DFD. Adding or omitting boundary flows between Level 0 and Level 1 is a severe modeling defect known as an unbalanced DFD .

Ecosystem Maps: Modeling Enterprise Interdependence

While a Context Diagram models the boundary of a single solution, modern enterprise business analysis rarely occurs in isolation. Digital transformations frequently span dozens of intertwined platforms, legacy mainframes, cloud-based software-as-a-service (SaaS) providers, and middleware integration hubs. For this broad vantage point, the business analyst constructs an Ecosystem Map .

Ecosystem Map vs. Context Diagram

A clear distinction is essential for the PMI-PBA candidate:

Context Diagram : Solution-centric. Focuses strictly on one system (Process 0) and shows all external entities that exchange data directly with that specific system.

Ecosystem Map : Architecture-centric and enterprise-wide. Shows all systems, applications, data platforms, and infrastructure components across an operational ecosystem and depicts how they connect to one another, regardless of which system is the focus of the current project.

Visualizing Integration Hubs and Blast Radius

In an Ecosystem Map, systems are depicted as nodes grouped by functional domains (e.g., Front-Office Channels, Core Processing, Back-Office Accounting, External Partner APIs).

Business analysts use Ecosystem Maps to evaluate:

Integration Mechanisms : Documenting whether connections utilize real-time synchronous REST APIs, asynchronous event streams (Kafka/RabbitMQ), batch enterprise service bus (ESB) routing, or nightly SFTP batch file transfers.

Change Blast Radius : If the project modifies the data format of the customer profile in the CRM, the Ecosystem Map immediately highlights every downstream system consuming that profile, exposing hidden regression risks.

Redundancy and Technical Debt : Ecosystem Maps frequently uncover duplicate data stores, circular data paths, and redundant point-to-point connections that should be refactored during project delivery.

Feature Breakdown Structures (FBS)

A Feature Breakdown Structure (FBS) is a hierarchical decomposition of the product scope into discrete, manageable functional capabilities. It organizes features into parent-child relationships, providing a visual taxonomy of what the solution will do.

Product Scope (FBS) vs. Project Scope (WBS)

A fundamental PMI-PBA concept is the strict distinction between the Feature Breakdown Structure and the Work Breakdown Structure:

  • Dimension Feature Breakdown Structure (FBS) Work Breakdown Structure (WBS)
  • Focus Product Scope (What the product does) Project Scope (The work required to deliver it)

Governing Question "What functional capabilities will the solution possess?" "What work packages must the team execute to deliver the product?"

Decomposition Elements Themes, Feature Groups, Features, Sub-Features, User Stories Project Management, Architecture, Engineering, QA Testing, Training, Rollout

Primary Custodian Business Analyst / Product Owner Project Manager

Longevity Persists throughout the multi-year lifecycle of the product Terminates upon administrative closure of the project

Measurement Baseline Requirements baseline, business case metrics, user acceptance Scope baseline, earned value (EVM), schedule/cost variance

Decomposition Levels in an FBS

A standard Feature Breakdown Structure decomposes through four rigorous tiers:

Level 0 (Product / Solution) : The overarching system (e.g., Omnichannel Retail Banking Platform).

Level 1 (Themes / Capability Areas) : Broad functional domains (e.g., Account Management, Payments & Transfers, Credit & Lending, Customer Support).

Level 2 (Feature Sets / Features) : Recognizable, marketable capabilities that deliver tangible value to a stakeholder (e.g., Peer-to-Peer Instant Transfer, Bill Pay, International Wire).

Level 3 (Sub-Features / Functional Units) : Granular behaviors supporting a feature (e.g., FX Currency Calculator, Recurring Payment Scheduler, Fraud Risk Confirmation).

Level 4 (Functional Requirements / User Stories) : Atomic specifications with testable acceptance criteria (e.g., "As a retail banking customer, I want to view live foreign exchange rates before executing a transfer so that I know the exact conversion fee." ).

In adaptive and hybrid lifecycles, the FBS forms the direct structural backbone of the Product Backlog and the User Story Map , enabling release planning teams to slice Minimum Viable Products (MVPs) across horizontal capability bands.

Use Case Diagrams: UML Scope and Interaction Modeling

The Unified Modeling Language (UML) Use Case Diagram provides an objective visual representation of user-system interactions. It models the system boundary, the human or machine actors that interact with the system, and the discrete business goals (use cases) those actors achieve.

Anatomy of a Use Case Diagram

System Boundary : Rendered as a distinct rectangular box enclosing all use cases. The label at the top identifies the solution. Use cases reside inside the box; actors reside outside the box.

Actors : External entities that interact with the solution to achieve a meaningful result. Rendered as stick figures (or rectangular class boxes with the «actor» stereotype):

Primary Actors : Initiate the interaction to achieve a primary business goal (e.g., Loan Applicant , Store Clerk ). Positioned on the left.

Secondary / Supporting Actors : Provide auxiliary services, data feeds, or infrastructure to help the system fulfill the use case (e.g., Payment Gateway , Email Notification Daemon , Identity Verification Service ). Positioned on the right.

Rule : Actors must represent roles, not specific job titles or individual names. An individual person can play multiple actor roles simultaneously.

Use Cases : Ovals containing an active verb-noun phrase representing a discrete, observable goal achieved by an actor (e.g., Submit Mortgage Application , Disburse Funds , Generate Monthly Statement ).

Associations : Solid lines connecting an actor to a use case. Indicates bidirectional or initiator interaction. Arrows are omitted unless specific unilateral communication directionality must be emphasized.

UML Relationships: <<include>> vs. <<extend>>

The PMI-PBA examination rigorously tests the candidate's understanding of the semantic differences between the <<include>> and <<extend>> stereotypes. Conflating these two relationships is one of the most common errors in business analysis. [ Base Use Case ] [ Included Use Case ]

  • ┌─────────────────────────┐ ┌─────────────────────────┐
  • │ │ │ │
  • │ Execute Wire │───────────>│ Authenticate │
  • │ Transfer │ <<include>>│ User │
  • │ │ │ │
  • └─────────────────────────┘ └─────────────────────────┘
  • ▲
  • │
  • │ <<extend>>
  • │ [Condition: Wire > $10,000]
  • │ [Extension Point: High-Value Verification]
  • ┌─────────────────────────┐
  • │ │
  • │ Trigger Manager │
  • │ Dual Approval │
  • │ │
  • └─────────────────────────┘
  • [ Extending Use Case ]
  • The <<include>> Relationship

Nature : Mandatory and Unconditional .

Definition : Represents shared, common behavior that is factored out of one or more base use cases into a reusable subroutine. The base use case cannot complete successfully without executing the included use case.

Execution Logic : Whenever the base use case runs, the included use case executes automatically and unconditionally at a specified point.

Arrow Direction : The dashed dependency arrow points from the Base Use Case to the Included Use Case ( Base ..> Included ). Think: the base use case needs or reaches out to include the subsidiary behavior.

Example : Execute Wire Transfer <<include>> Authenticate User . An authenticated user identity is an absolute prerequisite; the transfer cannot proceed without it.

The <<extend>> Relationship

Nature : Optional and Conditional .

Definition : Represents auxiliary, exceptional, or optional behavior that is added to a base use case only under specific, defined operational conditions. The base use case is completely functional and meaningful on its own without the extension.

Extension Points and Guard Conditions : The base use case defines an Extension Point (a specific hook in its workflow). The extending use case executes only if a specified guard condition evaluates to true at that extension point.

Arrow Direction : The dashed dependency arrow points from the Extending Use Case to the Base Use Case ( Extending ..> Base ). Think: the extending use case points to the base use case that it is modifying or extending.

Example : Trigger Manager Dual Approval <<extend>> Execute Wire Transfer with the condition [Amount > $10,000] . Standard wire transfers complete normally without manager approval; only high-value transfers trigger the conditional extension.

Generalization

Denotes an inheritance relationship between two actors or two use cases, indicated by a solid line with an unfilled triangular arrowhead pointing toward the generalized parent.

Actor Generalization : An Underwriting Supervisor inherits all use case associations possessed by a standard Underwriter , but possesses additional unique privileges.

Use Case Generalization : Pay by Credit Card and Pay by ACH are specializations that inherit the basic behavior of the generalized use case Process Payment .

Scope Modeling Techniques Comparison

The following table provides a direct comparative reference of the four primary scope modeling techniques evaluated on the PMI-PBA examination:

Technique Model Type Primary Perspective Key Elements Best Used For Common PMI-PBA Exam Pitfall

Context Diagram (DFD Level 0) Structured Data Flow Solution Boundary & Data Interfaces Single central process bubble (0), external entities, boundary data flows Establishing clear boundaries of a single software system or process; identifying all external data sources/sinks Incorrectly drawing internal data stores or internal sub-processes inside Level 0

Ecosystem Map Enterprise Architecture Multi-System Interdependence Systems, integration hubs (APIs, ESBs, queues), third-party SaaS, data flows Understanding enterprise-wide technical dependencies, upstream/downstream blast radius, and legacy integration Conflating the entire enterprise ecosystem with the immediate project solution scope

Feature Breakdown Structure (FBS) Hierarchical Tree Product Functional Decomposition Solution (L0), Themes (L1), Features (L2), Sub-features (L3), Stories (L4) Defining product scope boundaries, organizing backlogs, planning MVPs and release cadences Confusing product capability decomposition (FBS) with project delivery work packages (WBS)

Use Case Diagram UML Behavioral Actor-System Interactions System boundary box, primary/secondary actors, use case ovals, <<include>> , <<extend>> Documenting functional user goals, access boundaries, and shared versus conditional system behaviors Reversing arrow directions for <<include>> and <<extend>> , or drawing single UI clicks as use cases

Loading diagram... System Context Diagram (DFD Level 0) for an Enterprise Lending Platform