Identity
What exact dependency, source, version, supplier, and owner are we talking about?
Lesson A11.5
Modern software depends on packages, libraries, SDKs, build tools, registries, managed services, suppliers, and many other components. Secure architecture must understand those dependencies as part of the product — not as invisible implementation details.
This lesson uses fictional inventories and metadata only. You will evaluate ownership, source, version, support, runtime role, reachability, privilege, update difficulty, evidence, exceptions, and retirement without scanning or exploiting any real component.
Lesson Progress
High School Advanced • A11: Secure Software Architecture • Lesson 5 of 10
Readiness Check
0/4 ready
Professional Hook
A fictional engineering team may write only part of an application. The final service could still depend on an identity SDK, database driver, messaging client, scheduling vendor, build service, artifact-signing service, test framework, container image, and many transitive components.
If one of those components becomes unsupported, changes supplier, drifts from the approved version, loses an owner, or becomes difficult to update, the software architecture inherits that risk.
Dependencies are architecture decisions with lifecycle responsibilities.
Learning Objectives
Explain why dependency and software supply-chain risk includes more than package version numbers.
Evaluate fictional dependencies using ownership, business importance, provenance, support status, maintenance health, exposure, privilege, update path, validation evidence, and replacement difficulty.
Distinguish dependency presence, runtime use, reachable functionality, known risk, observed activity, and confirmed impact.
Design a defensive dependency-governance workflow covering intake, approval, inventory, update, exception, validation, monitoring, replacement, and retirement.
Build a dependency risk register that becomes the fifth artifact in the A11 Secure Software Design Assessment.
Why It Matters
Two applications can use the same component but have different risk because they use different functionality, environments, privileges, data, exposure, controls, or versions.
That is why professional dependency review asks for context instead of reacting only to package age or severity labels.
What exact dependency, source, version, supplier, and owner are we talking about?
Where is it used, what does it do, what can it access, and which trust boundaries does it cross?
What supports the current status, and what remains Unknown?
Core Framework
What dependencies does the software actually rely on?
Identify direct packages, important transitive dependencies, external services, registries, build tools, images, plugins, SDKs, and other third-party components that materially affect the software.
Why does this dependency matter?
Record business purpose, runtime role, privilege, exposure, data access, criticality, environment, and whether the dependency participates in build, release, or production behavior.
Is the source and maintenance model acceptable?
Review source, provenance, licensing or policy constraints, support status, maintainer activity, supplier trust, approved registry, and update expectations.
Can the team identify exactly what version or artifact is intended?
Record approved versions, integrity or provenance metadata where available, expected source, ownership, and build linkage so the team can distinguish intended artifacts from drift.
What changes could affect dependency risk?
Track support status, important advisories, ownership changes, supplier changes, version drift, new runtime use, environment exposure, and stale exceptions.
How should the team change versions safely?
Review compatibility, release notes, business impact, test evidence, rollback, dependent services, configuration changes, and validation before moving to a new version.
What happens when an immediate update is not practical?
Create a narrow, time-bounded, owned exception with rationale, compensating controls, monitoring, validation, target date, and closure criteria.
When should the team stop depending on the component?
Replace unsupported, unmaintained, incompatible, unnecessary, or strategically risky dependencies when the residual risk or maintenance burden is no longer acceptable.
Risk Dimensions
What happens to the product if the dependency fails, changes, or becomes unavailable?
Example: A date-formatting helper and the central identity SDK do not have the same business impact.
Is the dependency only present in development, used during build, or active in the released application?
Example: A test-only package should not automatically be treated as production runtime exposure.
Does the software actually use the functionality connected to the concern?
Example: Installed code is not automatically the same as active, reachable functionality.
What access or authority does the component have in the intended environment?
Example: A build tool with artifact-signing access deserves stronger governance than a local formatting utility.
Does the component process private, confidential, authentication, or security-relevant data?
Example: A logging integration handling audit events may require different review than a static icon package.
Where is the dependency used and which trust boundaries does it cross?
Example: A package used only in an offline build step differs from an internet-facing application component.
Can the team identify the approved source, artifact, supplier, and version?
Example: An ambiguous package source weakens confidence even when the version number looks current.
Is the dependency supported, actively maintained, and receiving appropriate updates?
Example: An abandoned component can become a long-term architecture risk even without a current incident.
How hard is it to validate, replace, or roll back the dependency?
Example: A deeply embedded framework may require a larger migration plan than a small isolated library.
Who is accountable for version review, exceptions, updates, and retirement?
Example: Unowned dependencies often remain stale because everyone assumes someone else is reviewing them.
Vocabulary
A library, package, SDK, service, build tool, plugin, image, supplier component, or other external element the software relies on.
A component the project intentionally includes or references directly.
A component included because another dependency relies on it.
Evidence describing where software or an artifact came from and how its identity can be related to an approved source or build process.
A maintained record of important components, versions, sources, owners, environments, roles, and lifecycle status.
Whether a component is currently maintained and supported by its project, supplier, or organization.
Whether the software actually uses or can invoke the functionality relevant to a dependency concern.
A difference between the approved or expected dependency version and what is recorded in another environment or artifact.
The people, projects, registries, tools, services, builds, artifacts, and suppliers that contribute to software delivery.
A governed, time-bounded decision to temporarily accept a dependency condition that does not meet the normal standard.
A safeguard used to reduce risk when the preferred control or update cannot be implemented immediately.
The controlled removal of a dependency and its associated permissions, configuration, build references, ownership, and monitoring responsibilities.
Evidence Discipline
Dependency findings become misleading when reviewers jump from “the component exists†directly to “the application was harmed.†Strong analysis keeps each claim separate.
Supporting evidence: Inventory, lock metadata, manifest, build record, or artifact record.
Limitation: Presence alone does not prove runtime use, reachability, harmful activity, or impact.
Supporting evidence: Architecture mapping, runtime package record, service-owner evidence, artifact composition.
Limitation: Runtime presence alone does not prove a specific risky function is reachable.
Supporting evidence: Safe design review, code-path evidence, approved test evidence, feature mapping.
Limitation: Reachability does not prove harmful use or confirmed impact.
Supporting evidence: Trusted advisory matched to exact component identity and version.
Limitation: An advisory does not by itself prove the affected function is used or that harm occurred.
Supporting evidence: Specific incident or monitoring evidence within an authorized investigation.
Limitation: Dependency age or advisory severity alone cannot establish this claim.
Supporting evidence: Application, data, identity, transaction, operational, or user evidence tied to the event.
Limitation: A dependency finding by itself does not prove business impact.
Fake Dashboard
Fictional inventory and lifecycle metadata
Tracked dependencies
126
Direct, material transitive, build, and external service records
Owned records
123 / 126
Three legacy records need ownership resolution
Supported baseline
94%
Four legacy components require migration or exception review
Open exceptions
5
All have owners; two expire within 30 days
Fake SOC Alert
Source: Fictional Dependency Review • Time: 09:27
Dependency Register
Role
Staff sign-in and identity claims
Environment
Production
Source
Approved supplier registry
Version
Approved baseline current
Runtime
Active
Privilege
Authentication context
Support
Supported
Owner
Identity Platform Team
Concern
No current exception
Next action
Continue scheduled version and support review.
Role
Outbound notification queue client
Environment
Production
Source
Approved registry
Version
Two approved minor releases behind target
Runtime
Active
Privilege
Notification service only
Support
Supported
Owner
Notification Service Team
Concern
Update is pending compatibility validation with retry behavior.
Next action
Complete authorized compatibility testing and schedule bounded update.
Role
Generates staff-only PDF reports
Environment
Production
Source
Approved internal mirror
Version
Legacy baseline
Runtime
Active
Privilege
Reads approved reporting data
Support
Limited support
Owner
Reporting Team
Concern
Replacement project is required because support ends this quarter.
Next action
Execute migration plan, validate replacement, and retire old component.
Role
Test-only assertion helper
Environment
CI Test
Source
Approved registry
Version
Current
Runtime
Not shipped to production
Privilege
Test environment only
Support
Supported
Owner
Engineering Productivity
Concern
Must remain separated from production artifact.
Next action
Verify build manifest continues to exclude test-only dependency.
Role
External scheduling integration
Environment
Production
Source
Supplier distribution
Version
Current approved
Runtime
Active
Privilege
Approved appointment fields only
Support
Supported
Owner
Integration Owner
Concern
Supplier migration next quarter may change provenance and API behavior.
Next action
Treat supplier migration as architecture and dependency change trigger.
Role
Old import workflow
Environment
Maintenance
Source
Unknown historical source
Version
Unknown
Runtime
Unclear
Privilege
Unknown
Support
Unknown
Owner
Unknown
Concern
Source, ownership, active use, version, and support are not established.
Next action
Determine whether the dependency is still needed before any release decision.
Role
Approved artifact-signing dependency
Environment
Build / Release
Source
Approved platform service
Version
Managed service
Runtime
Build pipeline only
Privilege
Release-signing authority
Support
Supported
Owner
Release Engineering
Concern
High privilege means ownership and access review must remain current.
Next action
Continue quarterly access and emergency-use review.
Fake Log Panel
[08:35] DEP-01 identity-sdk source=APPROVED support=SUPPORTED status=CONFIRMED [08:58] DEP-02 messaging-client update=pending compatibility-validation [09:27] DEP-03 report-renderer support-ending -> migration BLOCKED [09:55] DEP-04 unit-test-helper production-artifact=NOT PRESENT [10:22] DEP-05 supplier-migration flagged as change-trigger [10:47] DEP-06 source=UNKNOWN owner=UNKNOWN runtime-use=UNKNOWN [11:15] DEP-07 signing-service privilege=HIGH owner=ReleaseEngineering status=CONFIRMED
Training note: this is fake data for defensive analysis practice only.
Review Questions
What exact component or external service is this?
Why does the software depend on it?
Is it direct, transitive, build-time, test-only, runtime, or external service dependency?
Which environment uses it?
Who owns the dependency?
What source or supplier is approved?
Which version or artifact identity is expected?
Is the component supported and maintained?
What privilege or data access does it have?
Which trust boundaries does it cross?
Is the relevant functionality actually used or reachable?
What security controls reduce dependency risk?
What evidence supports the current status?
How difficult is update or replacement?
What rollback or recovery plan exists?
What monitoring detects drift, stale support, or exception expiry?
What change triggers require architecture or threat-model review?
What retirement criteria close the dependency lifecycle?
Analyze the Evidence
Update Strategy
Updating a dependency can reduce one risk while introducing compatibility, configuration, performance, or operational change. Strong teams use an evidence-based change process.
Confirm exact component identity and approved source.
Review support status and relevant release information.
Understand runtime role, privilege, data access, and dependencies.
Define expected behavior and compatibility criteria.
Validate in an authorized non-production environment.
Review configuration changes and migration notes.
Plan rollback and monitoring.
Deploy through approved change control.
Validate intended version and service behavior after deployment.
Update inventory, baseline, exception, and retirement records.
Exceptions
Sometimes a dependency cannot be updated immediately because of compatibility, supplier timing, migration complexity, or business constraints. That does not mean the risk should disappear from view.
Which exact component, version, environment, and workflow are covered?
Why is the normal requirement not currently achievable?
Who is accountable for the exception and closure?
Which compensating safeguards reduce the temporary risk?
How will the team watch for changes while the exception is active?
When must the exception be reviewed or closed?
What update, migration, replacement, or retirement resolves the exception?
What evidence proves the temporary condition is gone?
Common Mistakes
Why it fails: Business importance, runtime use, privilege, exposure, controls, support, and reachability can differ greatly.
Better approach: Prioritize with a consistent risk model and explain the evidence.
Why it fails: Important transitive components and supplier services can affect the software too.
Better approach: Maintain an inventory that captures materially important transitive and service dependencies.
Why it fails: A version change can create compatibility, configuration, or operational risk that still needs validation.
Better approach: Use approved update workflows with evidence, rollback, and post-change validation.
Why it fails: A familiar package name does not by itself establish that the artifact came from the approved source or build path.
Better approach: Track approved source, artifact identity, version, and build linkage.
Why it fails: Unowned dependencies can remain stale, unsupported, or exception-bound indefinitely.
Better approach: Assign accountable owners for review, updates, exceptions, and retirement.
Why it fails: Temporary risk can silently become the normal architecture.
Better approach: Make exceptions narrow, time-bounded, monitored, owned, and linked to closure criteria.
Why it fails: Compatibility failures can disrupt service or force rushed changes.
Better approach: Plan validation, staged rollout, monitoring, and rollback.
Why it fails: Known risk in a dependency does not prove the software was harmed.
Better approach: Separate component risk, reachability, observed activity, and business impact.
Scenario Decision Lab
The fictional Legacy Report Renderer remains active in production. Limited support ends this quarter. A replacement component has been selected, but compatibility and rollback validation are not complete.
Scenario Decision Lab
A historical CSV utility appears in an old maintenance inventory. Its source, version, owner, support status, and current runtime use are all Unknown.
Safe Fictional Lab
Use fictional components only. Do not scan, download, inspect, exploit, or test real software packages, registries, repositories, services, or systems.
Create at least ten fictional dependency records.
Give each dependency a stable ID.
Record business purpose and application role.
Classify direct, transitive, test, build, runtime, or external-service use.
Record environment and approved source.
Record version or artifact identity metadata.
Assign an owner.
Record support and maintenance status.
Describe privilege, data access, and trust boundaries.
Record evidence for runtime use or reachability when relevant.
Assign status: Confirmed, Conditional, Unknown, Blocked, or Retired.
Define update, exception, replacement, or retirement action.
Add change triggers.
Add validation and rollback expectations.
Analyze the Evidence
Advanced Challenge
Create a fictional exception for a business-critical dependency that cannot be updated for 45 days because the replacement requires a compatibility change.
Exact dependency ID and version
Business reason for temporary delay
Affected environment and workflow
Runtime role and privilege
Known concern and evidence
Compensating controls
Monitoring
Accountable owner
Target update or replacement date
Validation plan
Rollback plan
Expiration date
Closure criteria
Residual risk statement
Defender Habits
Skill Check
Check Your Understanding
Choose your answers first. Explanations appear only after submission.
Portfolio Prompt
Create the fifth artifact for your A11 Secure Software Design Assessment: a fictional dependency risk register with at least ten records. Include ID, component or service name, purpose, dependency type, environment, source or supplier, version or artifact metadata, runtime role, privilege, data access, support status, owner, evidence, status, exception or update plan, validation, rollback, change triggers, and retirement criteria.
Confidence / Readiness Reflection
A11.6 moves to Secure Error Handling and Logging. Before continuing, check whether you can explain dependency risk without turning every component finding into a claim of compromise.
I can identify direct, transitive, build, test, runtime, and external-service dependencies.
I can evaluate ownership, source, support, runtime role, privilege, exposure, and replacement difficulty.
I can separate component presence, reachability, advisory match, observed activity, and confirmed impact.
I can design a governed update or exception process with validation and rollback.
I can define when a dependency should be replaced or retired.
Portfolio Build Guide
Give each material dependency a unique identifier so architecture, review, testing, release, and maintenance evidence can reference it.
Distinguish test-only, build-time, runtime, service, and privileged dependencies.
Record environment, business purpose, source, version, support status, data access, and privilege.
Do not claim compromise or impact from version data alone.
Every material dependency should have an accountable review and maintenance owner.
Record validation, compatibility, rollback, monitoring, and deployment expectations.
Keep exceptions narrow, time-bounded, owned, monitored, and connected to closure criteria.
Unsupported, unnecessary, or strategically risky dependencies should have a clear replacement or retirement path.
Key Takeaways
Lesson Safety Boundary
This lesson does not authorize scanning, downloading, probing, exploiting, fuzzing, modifying, or testing real packages, registries, repositories, services, devices, applications, or networks. Use fictional inventories and supplied metadata only.
Lesson Complete
You now have a dependency-governance framework covering identity, provenance, support, ownership, runtime role, reachability, updates, exceptions, replacement, and retirement. Next, A11.6 focuses on Secure Error Handling and Logging.