SDLC Component and Capability Catalogue
The reusable starter-kit components and platform-shared capabilities every new application should inherit, grouped into four SDLC regimes, with the conventions to fix once, provider equivalents, owners, the mapping to the eight SDLC controls, a gap-analysis procedure and acceptance checks.
- Version
- 0.1.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 16 min
For Cto · Ai Architect · Platform Engineer · Risk And Assurance · Internal Audit
Sources and details
- Section
- Deliver changes
- Source works
- Book 1 · Book 2
- Source chapters
- 6, 15
- Source appendices
- 01:F
- Refresh trigger
- vendor release
This page is the parts list behind the standard application foundation: the starter-kit components an application is scaffolded from, and the platform-shared capabilities it calls instead of building its own. Use it to run a gap analysis of the kit you already have, to decide which capability a product team may not rebuild, and to show an auditor which shared asset carries which SDLC control.
It complements two neighbours. Build the standard application foundation (Book 2’s view) covers how the foundation is funded, versioned, contracted and adopted. The agent-speed SDLC covers the eight SDLC controls themselves. This page is the catalogue that sits between them (Book 1, Appendix F and Chapter 15 §5.3).
How to use this catalogue
It is a shopping list, not a build list (source claim, Book 1 App F). The entries name the categories your platform should be able to point to. They are not a specification to copy item by item. Most large regulated firms already run a starter kit; the expected move is to map that kit against the four regimes, name the gaps and close them. Building the catalogue from scratch is explicitly not recommended. The rule is to adopt and adapt.
Provider columns are dated. The Microsoft, AWS and Google Cloud tooling named below is the May 2026 market view Book 1 uses for its cross-cloud examples. Equivalent commercial or open-source tools are acceptable substitutes, provided each platform-shared capability lands somewhere named and owned. [FACT-CHECK: confirm every named service and SDK against current Microsoft, AWS and Google Cloud documentation before relying on it; service names and GA status move quarterly.]
Status of the content. The catalogue is a recommendation [REC] in Book 1’s labelling, not a regulatory requirement. Where a row below carries [REQ], [EXP] or [PREF], the label is Book 1’s own reading of the regulatory weight; the article-level analysis lives on the regulatory map.
Why standardise the plumbing
Book 1 gives the kit two purposes:
- Stop reinventing the same things. A team that writes its own token-validation middleware will eventually get it wrong. A team on the kit inherits every fix the platform team ships.
- Make agents transferable across applications. This is the AI-era reason. A diagnostic agent that understands the telemetry, health-check and audit-log conventions of one application can investigate any application built on the same kit. A code-generation agent can add an endpoint correctly because the deployment pattern, secret binding and error contract are predictable. With one task service, an agent learns “task” once; with a bespoke task model per application, it must learn each one.
The author’s position (Book 1 Ch 15 §5.3): standardising the plumbing removes low-value variance and leaves the high-value variance, the business capability, to the team. The unit of leverage is the platform-shared capability, not the per-application feature.
Two “four-regime” models: keep them apart
Book 1 Chapter 15 uses “four regimes” for two different things. Do not merge them.
| Model | The four regimes | What it classifies | Where it is used |
|---|---|---|---|
| SDLC regimes of the foundation (this page) | Identity and access · Change and deployment · Observability and evidence · Foundation and interaction | The parts of the starter kit and shared capabilities | Grouping this catalogue; gap analysis |
| Governance regimes of the portfolio | Bought · Built · No-code / low-code · Agent-created | How an application came into existence, and how it fails | Registering every application, including no-code flows and agent-created assets, so the SDLC controls apply to them |
The Chapter 15 checklist item “no-code and agent-created artefacts registered in the application portfolio under the four-regime model” refers to the second model. An agent-created asset inherits the governance perimeter and accountability of the wrangler of the agent that created it (source claim, Book 1 Ch 15 §4.4; see accountability).
Regime 1 — Identity and access
Components
| # | Component | Convention to fix once | Microsoft | AWS | Google Cloud |
|---|---|---|---|---|---|
| 1 | Identity integration | One enterprise identity provider; conditional access inherited, not re-implemented | MSAL + Entra ID | AWS SDK + Cognito or IAM Identity Center | Identity Platform SDK + workload identity pools |
| 2 | Role model | RBAC stub mapped to directory groups. Canonical roles: reader / editor / administrator / auditor, plus per-application extensions | Entra groups | IAM Identity Center groups | Cloud Identity groups |
| 3 | Security baseline | Headers set by default: CSP, HSTS, anti-CSRF, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy. Reviewed quarterly by the application-security lead | Same set | Same set | Same set |
Capabilities
| Capability | Purpose | Owner / caller |
|---|---|---|
| Role management | Role assignments across the portfolio; joiner, mover and leaver hooks | Wrangler-owned; agent-callable through API management |
| API access | Issue, rotate and revoke API keys and service-principal credentials; the secret-rotation timer runs in the pipeline | Wrangler-owned at registration; agent-callable; control-plane lifecycle hooks |
Regime 2 — Change and deployment
Components
| # | Component | Convention to fix once | Microsoft | AWS | Google Cloud |
|---|---|---|---|---|---|
| 4 | Configuration model | Secrets and settings in separate stores; standard naming, rotation and scopes; developer identity separated from deployment identity | Key Vault + App Configuration | Secrets Manager + Parameter Store | Secret Manager + Runtime Config |
| 5 | Deployment pipeline | Infrastructure as code; OIDC federation (no long-lived pipeline secrets); review gates pre-wired: lint, security scan, architecture conformance, coverage delta | Bicep + GitHub Actions or Azure DevOps | CloudFormation + CodePipeline or GitHub Actions | Cloud Deployment Manager + Cloud Build |
| 6 | Infrastructure template | Standard SKU, tagging, private-endpoint posture and diagnostic settings | App Service or Container Apps | ECS Fargate or App Runner | Cloud Run or GKE Autopilot |
| 7 | Feature flags | Flag taxonomy release / experiment / operational / permission; expiry hygiene; every flag change audit-wired | App Configuration feature management | AppConfig feature flags | Firebase Remote Config or a SaaS service |
Capabilities
| Capability | Purpose | Owner / caller |
|---|---|---|
| Approval workflow | Structured approvals used by the virtual CAB, agent registration, model-usage registration and four-eyes sign-off | Wrangler-owned; agent-callable |
| Feature flags (platform) | Typed API exposing the flag service to applications outside the starter kit, including legacy ones | Wrangler-owned at registration; agent-callable |
| Data export | Structured, audited, retention-aware export to downstream stores; produces the artefacts for data-subject access and portability requests | Data office; agent-callable |
The approval-workflow capability is what change governance writes its decisions against. Build it once; do not let each product grow its own approval table.
Regime 3 — Observability and evidence
Components
| # | Component | Convention to fix once | Microsoft | AWS | Google Cloud |
|---|---|---|---|---|---|
| 8 | Audit logging | Structured events forwarded to the SIEM; emitted in the Audit Evidence Schema; one correlation-ID convention; retention signed off by records management | App Insights → Sentinel | CloudWatch Logs → Security Lake | Cloud Audit Logs → Chronicle |
| 9 | Telemetry | OpenTelemetry; trace-context propagation across HTTP and message bus; one metric namespace per application | App Insights + OpenTelemetry | CloudWatch metrics + X-Ray | Cloud Monitoring + Cloud Trace |
| 10 | Health checks | /health (liveness) and /ready (ready to accept traffic). The standard payload distinguishes alive from alive and dependencies responding. Probes wired to the platform; alerts to the SOC | Platform probes | ECS health checks | Cloud Run liveness probes |
| 11 | Error handling | RFC 7807 problem-details JSON, standard fields plus firm extensions correlation_id, customer_safe_message, internal_diagnostic_code. Middleware converts uncaught exceptions; an audit hook records each with its correlation ID | Same convention | Same convention | Same convention |
Capabilities
| Capability | Purpose | Owner / caller |
|---|---|---|
| Telemetry (platform) | Typed telemetry API for applications outside the kit, using the same correlation conventions | Platform; agent-callable |
| Audit history | Query the audit log by entity, user, agent and time window. Serves wrangler periodic review, SOC investigation and data-subject access requests | Platform; agent-callable |
| Reporting | Structured reports (PDF, CSV, Excel, JSON) with standard retention, for regulatory, management and customer reporting | Platform; agent-callable |
| Search | Full-text search across application data with sensitivity-label filtering and a query-audit trail; used by the agent-readable data dictionary | Platform; agent-callable |
The audit-logging component is where the audit evidence schema meets application code. Health checks, telemetry and audit logging are also what resilience testing exercises (Book 1 App F.7), so a product that bypasses them is untestable as well as unobservable.
Regime 4 — Foundation and interaction
Components
| # | Component | Convention to fix once | Microsoft | AWS | Google Cloud |
|---|---|---|---|---|---|
| 12 | Standard shell and navigation | Frame, header, menu, breadcrumbs; firm branding, accessibility and breakpoints preset | Fluent UI | Cloudscape | The firm’s design-system equivalent |
| 13 | API client pattern | Typed clients generated from OpenAPI, with retry and circuit breakers; retry aligned to the dependency’s SLA; trace-context propagation | Same pattern | Same pattern | Same pattern |
| 14 | Localisation support | Resource files for the firm’s working languages (Book 1 lists French, German, Italian, English, Spanish, Portuguese, Dutch); standard fallback rules; right-to-left where required; translation-management integration | Same | Same | Same |
| 15 | Documentation template | OpenAPI for the contract; README for humans; an ADR directory; the firm’s CHANGELOG format; a doc linter in the pipeline; ADR-freshness check at 18 months; AI-readable annotations | Same | Same | Same |
Capabilities
| Capability | Purpose | Owner / caller |
|---|---|---|
| User profile | Typed profile API: name, role, line manager, conditional-access posture, sensitivity clearance | Platform; agent-callable |
| Presence status | Available, busy, in meeting, away, on holiday; derived from calendar, chat and HR sources | Platform; agent-callable |
| Notifications | Email, chat, mobile push, and SMS where regulation requires; standard templating, rate limiting, audit trail | Platform; agent-callable |
| Commenting | Threaded comments on entities, with mentions, sensitivity-label propagation and retention (credit approvals, claims, KYC files) | Platform; agent-callable |
| Activity feed | Who did what, when, on which entity: a user-visible projection of the audit log | Platform; agent-callable |
| Chat | Chat-platform integration: standard bot framework, sensitivity-label propagation, archiving | Platform; agent-callable |
| Task assignment | Create, assign and track tasks, with standard prioritisation, escalation and case-management integration | Platform; agent-callable |
| Attachments | Storage, malware scan, sensitivity-label inference, retention and download audit | Platform; agent-callable |
| Help and support integration | In-app help wired to the knowledge base, ticketing and an AI-assisted help agent | Platform; agent-callable |
The capability contract: agent-callable through one surface
Every shared capability is agent-callable through the firm’s API management surface (source claim, Book 1 Ch 15 §5.3, App F.7). That one rule produces four obligations for the platform team:
- One typed API per capability, published in the API catalogue and, for agent consumers, behind the MCP and connector broker. No application exposes its own private “task” or “comment” model where the shared one would do.
- Labels travel through the gateway. Data export and audit history carry sensitivity labels through API management, so an agent calling them gets no more than its entitlements allow.
- Calls are attributable. Agent calls run under the agent’s own identity, not a human’s or the deployment identity (see identity and secrets).
- Wrangler-owned capabilities are registered with an owner. Role management, API access, approval workflow and platform feature flags are wrangler-owned at registration in Book 1’s table; the others are platform-owned, and data export belongs to the data office.
Recommendation (this page). Record each catalogue entry with at least: entry ID, regime, kind (component or capability), the convention it fixes, the provider implementation and version, owner, permitted callers, the SDLC controls it carries (next section), the evidence it emits, and the date of its last review. Book 1 does not specify a record schema; these fields are the minimum needed to answer the auditor’s questions below.
Which shared asset carries which SDLC control
Book 1 App F.6 maps the catalogue onto the eight SDLC controls of Chapter 15. The controls themselves, their failure modes and labels are on the agent-speed SDLC.
| SDLC control | Component(s) that carry it | Capability(ies) that carry it |
|---|---|---|
| 1. Automated review gates before human review | Deployment pipeline (5) | — |
| 2. AI-era pull-request template | Documentation template (15), deployment pipeline (5) | Audit history |
| 3. Two human reviewers on changes touching a critical or important function | Deployment pipeline (5), role model (2) | Approval workflow, role management |
| 4. Mandatory dynamic analysis on authentication, authorisation, payment and customer-data changes | Deployment pipeline (5), security baseline (3) | — |
| 5. Architecture conformance enforced at PR time | Deployment pipeline (5), documentation template (15) | — |
| 6. Library and framework pinning in a per-repository policy file | Configuration model (4), deployment pipeline (5) | — |
| 7. Agents commit under their own identity | Identity integration (1), role model (2) | API access, role management |
| 8. Deployment identity separated from developer identity | Identity integration (1), deployment pipeline (5) | API access |
Read the table both ways. Forwards, it tells the platform team which component must be in the kit before a control can be claimed. Backwards, it tells an auditor where to look: if the pipeline component is missing or bypassed, controls 1 to 6 and 8 have no carrier.
Run a gap analysis of your existing kit
Who: the platform lead, with the application-security lead for Regime 1 and records management for component 8. Output: a gap register with an owner and date per gap.
- List what you run. Inventory the starter kits, templates and shared services in use, and the applications on each (including no-code flows and agent-created assets, registered under the governance regimes above).
- Map to the regimes. For each of the 15 components and 18 capabilities, record present and adopted, present but optional, or absent. “Present but optional” is a gap: an option teams can skip is not an inherited control.
- Check the fixed conventions, not just presence. For each component, test the convention: are the four canonical roles used; does
/readydistinguish dependency health; do error responses carrycorrelation_id; is the flag taxonomy applied and are expired flags removed; does the ADR-freshness check run. - Check agent-callability. For each capability, confirm a typed API exists behind API management and that an agent identity can call it with labels enforced.
- Map gaps to controls. Use the control table above to rank gaps. A gap in the pipeline, identity integration or API access component blocks several SDLC controls at once; close those first.
- Decide adopt, adapt or buy. Prefer forking an existing published starter kit or the firm’s own to writing a new one.
- Publish the catalogue entry for each closed gap, with its owner and version, and record the change in the foundation contract on the application foundation page.
Size the work to the firm (Book 1 Ch 15 §7)
| Firm | Approach | Book 1 guidance |
|---|---|---|
| ~50,000 employees | Engineer it | Commission the platform team to write the starter kit if none exists, and to publish the per-repository policy file the AI assistants read. Run it as a parallel workstream to the PR-template and review-gate rollout: about one quarter, eight to ten people [REC] |
| ~1,000 employees | Buy and adopt | Adopt a published starter kit; fork it, do not rewrite it [REC]. At around twenty engineers, buy architecture-conformance tooling rather than writing fitness functions [PREF]. Deployment-identity separation is not negotiable at any size [REQ] |
Ownership
| Role | Owns | Cadence |
|---|---|---|
| Platform team | The kit, the capability APIs, the catalogue entries and versions | Continuous; release notes per version |
| Application-security lead | Security baseline (component 3) | Quarterly review |
| Records management | Retention of audit logging (component 8) | Signed per retention class |
| Data office | Data-export capability | On change of retention or export rules |
| Wranglers | Wrangler-owned capabilities for their agents (role management, API access, approval workflow, platform flags) | At registration and periodic review |
| Head of compliance | Mapping of the eight SDLC controls to the regulations that require or expect them; annual attestation that CODEOWNERS coverage and deployment-identity separation are current across the critical-function estate | Annual |
| Head of internal audit | Sample test of attribution: agents commit under their own identity, the wrangler of record is named, and no agent service principal holds standing production access | Half-yearly |
Compliance and audit run these SDLC-side deliverables together with their data-side deliverables (Book 1 Ch 16), on the same cadence (source claim, Book 1 Ch 15 §7.3).
Failure modes and recovery
| Failure | How you recognise it | Recovery |
|---|---|---|
| The catalogue treated as a build manifest | A programme plan to build all 33 entries before any product ships; a new kit written beside an existing one | Map the existing kit; build only the gaps; fork published kits |
| Bespoke capabilities per application | Several applications with their own task, comment or approval model; agents carry per-application adapters | Route new work to the shared capability; migrate the highest-traffic bespoke copies first; record each remaining deviation in the foundation contract |
| Deployment identity used by an agent at runtime | The agent’s service principal is the same identity humans use for emergency production access, or holds a broad production role | Separate immediately: own service principal, minimum role, time-bound where possible, registered in the control plane; break-glass stays with humans (Book 1 Ch 15 §8.3) |
| Conventions present on paper only | Health endpoints exist but /ready never reports dependency failure; error bodies lack correlation_id; flags never expire | Add the convention as a pipeline check (architecture conformance, control 5), not a guideline |
| Optional kit | Teams can create a repository without the kit and nothing fails | Make the kit the only sanctioned template; treat out-of-kit repositories as deviations with an owner and date |
| AI reviewer replacing the human | Fewer reviewer-requested changes after an AI reviewer is enabled; rising post-merge defects | Demote the AI reviewer to a non-blocking commenter; restore human review (Book 1 Ch 15 §8.2) |
Acceptance checks
- Every component and capability has a catalogue entry with owner, version and last review date, or a dated gap in the register.
- A new repository created today inherits components 1–15 without manual steps, and the pipeline fails if one is removed.
- Each capability is callable through API management by an agent identity, with sensitivity labels enforced on data export, audit history and search.
- For each of the eight SDLC controls, you can name the component or capability that carries it and show its evidence.
- The security baseline has a dated quarterly review; audit-log retention has a records-management sign-off.
- An internal-audit sample in the last six months found no agent service principal with standing production access.
Source notes and conflicts
- Eighteen components or fifteen? Book 1 Ch 15 §5.3 and the opening of App F describe an “eighteen-component” starter kit with eighteen shared capabilities. The appendix’s own tables number fifteen components (1–15) and list eighteen capabilities, and the chapter’s regime summary names the same fifteen components. This page follows the tables (15 + 18) and does not invent three further components. [FACT-CHECK: confirm with the author whether three components are missing from App F or the “eighteen” in the prose is an error.]
- Book 1 versus Book 2. Book 2 Ch 6 describes the foundation as a plumbing catalogue with a foundation contract, funding and upgrade model (application foundation). The two views are compatible layers: Book 2 says how to run the foundation as a product; Book 1’s catalogue lists the parts. Where they name capabilities differently (for example Book 2’s three-level feature flags against Book 1’s four-value flag taxonomy), record both decisions in the foundation contract; they answer different questions (scope of a flag versus its purpose).
- Vendor specifics are Book 1’s May 2026 view. Book 1 also names a published Microsoft enterprise application starter kit and open-source AWS and GCP equivalents without citing them. [FACT-CHECK: identify and verify the specific starter kits before recommending one.]
Source material
- Book 1 (Building Organizations for the Age of AI), Appendix F, SDLC Component and Capability Catalogues (F.2–F.7)
- Book 1, Chapter 15, SDLC in the Age of AI (§4.4 four governance regimes; §4.5 Microsoft, AWS, GCP equivalents; §5.1 eight SDLC controls; §5.3 the standard application foundation; §7 practical application; §8 anti-patterns)
- Book 2 (The AI Delivery Factory), Chapter 6, The Standard Application Foundation (for the relationship to the plumbing catalogue)
Related guidance
-
The Agent-Speed SDLCA committed artefact chain, governed context, trusted tests and eight SDLC controls that let coding agents work quickly while intent, review, identity and evidence stay connected. -
Build the Standard Application FoundationRun the shared identity, telemetry, deployment, data and AI capabilities as a funded product that humans and agents both start from, with a contract, evidence-computed trust, a cheap promotion boundary and reuse measured by consumption. -
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Govern APIs, Data Products and Retrieval Agents Can TrustTurn interfaces and data into owned, versioned capabilities that applications and agents consume under identity, entitlement and evidence controls, and give agents access to meaning, limits and authority, not only bytes. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation. -
Release Engineering for Agent-Written ChangeMove agent-speed change into production through five evidence-emitting stations: one change type per change, a reversal decided at authoring, a valid Deployer Manifest, a gateway that cannot be bypassed, hard health gates and at-most-once rollback. -
Build a Living Product Bill of Material and RecipeDescribe what an AI product contains and how the firm builds it in one versioned specification shared by pipelines, agents and assurance teams, including the classification line, readiness grades and reuse generations. -
Schemas, Conformance Packs and the ops ToolchainWhat the versioned Supporting Tools schemas hosted under /aes/v0.1.0/ require, how to validate against them, where the source specification contradicts itself, and what the planned ops CLI, Claude plugins and service conventions define.