Browse the reference ⌄
Artefact published

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
Source works
Book 1 · Book 2
Source chapters
6, 15
Source appendices
01:F
Refresh trigger
vendor release

Full source list ↓ Source index →

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:

  1. 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.
  2. 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.

ModelThe four regimesWhat it classifiesWhere it is used
SDLC regimes of the foundation (this page)Identity and access · Change and deployment · Observability and evidence · Foundation and interactionThe parts of the starter kit and shared capabilitiesGrouping this catalogue; gap analysis
Governance regimes of the portfolioBought · Built · No-code / low-code · Agent-createdHow an application came into existence, and how it failsRegistering 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

#ComponentConvention to fix onceMicrosoftAWSGoogle Cloud
1Identity integrationOne enterprise identity provider; conditional access inherited, not re-implementedMSAL + Entra IDAWS SDK + Cognito or IAM Identity CenterIdentity Platform SDK + workload identity pools
2Role modelRBAC stub mapped to directory groups. Canonical roles: reader / editor / administrator / auditor, plus per-application extensionsEntra groupsIAM Identity Center groupsCloud Identity groups
3Security baselineHeaders set by default: CSP, HSTS, anti-CSRF, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy. Reviewed quarterly by the application-security leadSame setSame setSame set

Capabilities

CapabilityPurposeOwner / caller
Role managementRole assignments across the portfolio; joiner, mover and leaver hooksWrangler-owned; agent-callable through API management
API accessIssue, rotate and revoke API keys and service-principal credentials; the secret-rotation timer runs in the pipelineWrangler-owned at registration; agent-callable; control-plane lifecycle hooks

Regime 2 — Change and deployment

Components

#ComponentConvention to fix onceMicrosoftAWSGoogle Cloud
4Configuration modelSecrets and settings in separate stores; standard naming, rotation and scopes; developer identity separated from deployment identityKey Vault + App ConfigurationSecrets Manager + Parameter StoreSecret Manager + Runtime Config
5Deployment pipelineInfrastructure as code; OIDC federation (no long-lived pipeline secrets); review gates pre-wired: lint, security scan, architecture conformance, coverage deltaBicep + GitHub Actions or Azure DevOpsCloudFormation + CodePipeline or GitHub ActionsCloud Deployment Manager + Cloud Build
6Infrastructure templateStandard SKU, tagging, private-endpoint posture and diagnostic settingsApp Service or Container AppsECS Fargate or App RunnerCloud Run or GKE Autopilot
7Feature flagsFlag taxonomy release / experiment / operational / permission; expiry hygiene; every flag change audit-wiredApp Configuration feature managementAppConfig feature flagsFirebase Remote Config or a SaaS service

Capabilities

CapabilityPurposeOwner / caller
Approval workflowStructured approvals used by the virtual CAB, agent registration, model-usage registration and four-eyes sign-offWrangler-owned; agent-callable
Feature flags (platform)Typed API exposing the flag service to applications outside the starter kit, including legacy onesWrangler-owned at registration; agent-callable
Data exportStructured, audited, retention-aware export to downstream stores; produces the artefacts for data-subject access and portability requestsData 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

#ComponentConvention to fix onceMicrosoftAWSGoogle Cloud
8Audit loggingStructured events forwarded to the SIEM; emitted in the Audit Evidence Schema; one correlation-ID convention; retention signed off by records managementApp Insights → SentinelCloudWatch Logs → Security LakeCloud Audit Logs → Chronicle
9TelemetryOpenTelemetry; trace-context propagation across HTTP and message bus; one metric namespace per applicationApp Insights + OpenTelemetryCloudWatch metrics + X-RayCloud Monitoring + Cloud Trace
10Health 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 SOCPlatform probesECS health checksCloud Run liveness probes
11Error handlingRFC 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 IDSame conventionSame conventionSame convention

Capabilities

CapabilityPurposeOwner / caller
Telemetry (platform)Typed telemetry API for applications outside the kit, using the same correlation conventionsPlatform; agent-callable
Audit historyQuery the audit log by entity, user, agent and time window. Serves wrangler periodic review, SOC investigation and data-subject access requestsPlatform; agent-callable
ReportingStructured reports (PDF, CSV, Excel, JSON) with standard retention, for regulatory, management and customer reportingPlatform; agent-callable
SearchFull-text search across application data with sensitivity-label filtering and a query-audit trail; used by the agent-readable data dictionaryPlatform; 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

#ComponentConvention to fix onceMicrosoftAWSGoogle Cloud
12Standard shell and navigationFrame, header, menu, breadcrumbs; firm branding, accessibility and breakpoints presetFluent UICloudscapeThe firm’s design-system equivalent
13API client patternTyped clients generated from OpenAPI, with retry and circuit breakers; retry aligned to the dependency’s SLA; trace-context propagationSame patternSame patternSame pattern
14Localisation supportResource 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 integrationSameSameSame
15Documentation templateOpenAPI 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 annotationsSameSameSame

Capabilities

CapabilityPurposeOwner / caller
User profileTyped profile API: name, role, line manager, conditional-access posture, sensitivity clearancePlatform; agent-callable
Presence statusAvailable, busy, in meeting, away, on holiday; derived from calendar, chat and HR sourcesPlatform; agent-callable
NotificationsEmail, chat, mobile push, and SMS where regulation requires; standard templating, rate limiting, audit trailPlatform; agent-callable
CommentingThreaded comments on entities, with mentions, sensitivity-label propagation and retention (credit approvals, claims, KYC files)Platform; agent-callable
Activity feedWho did what, when, on which entity: a user-visible projection of the audit logPlatform; agent-callable
ChatChat-platform integration: standard bot framework, sensitivity-label propagation, archivingPlatform; agent-callable
Task assignmentCreate, assign and track tasks, with standard prioritisation, escalation and case-management integrationPlatform; agent-callable
AttachmentsStorage, malware scan, sensitivity-label inference, retention and download auditPlatform; agent-callable
Help and support integrationIn-app help wired to the knowledge base, ticketing and an AI-assisted help agentPlatform; 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:

  1. 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.
  2. 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.
  3. Calls are attributable. Agent calls run under the agent’s own identity, not a human’s or the deployment identity (see identity and secrets).
  4. 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 controlComponent(s) that carry itCapability(ies) that carry it
1. Automated review gates before human reviewDeployment pipeline (5)—
2. AI-era pull-request templateDocumentation template (15), deployment pipeline (5)Audit history
3. Two human reviewers on changes touching a critical or important functionDeployment pipeline (5), role model (2)Approval workflow, role management
4. Mandatory dynamic analysis on authentication, authorisation, payment and customer-data changesDeployment pipeline (5), security baseline (3)—
5. Architecture conformance enforced at PR timeDeployment pipeline (5), documentation template (15)—
6. Library and framework pinning in a per-repository policy fileConfiguration model (4), deployment pipeline (5)—
7. Agents commit under their own identityIdentity integration (1), role model (2)API access, role management
8. Deployment identity separated from developer identityIdentity 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.

  1. 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).
  2. 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.
  3. Check the fixed conventions, not just presence. For each component, test the convention: are the four canonical roles used; does /ready distinguish dependency health; do error responses carry correlation_id; is the flag taxonomy applied and are expired flags removed; does the ADR-freshness check run.
  4. 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.
  5. 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.
  6. Decide adopt, adapt or buy. Prefer forking an existing published starter kit or the firm’s own to writing a new one.
  7. 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)

FirmApproachBook 1 guidance
~50,000 employeesEngineer itCommission 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 employeesBuy and adoptAdopt 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

RoleOwnsCadence
Platform teamThe kit, the capability APIs, the catalogue entries and versionsContinuous; release notes per version
Application-security leadSecurity baseline (component 3)Quarterly review
Records managementRetention of audit logging (component 8)Signed per retention class
Data officeData-export capabilityOn change of retention or export rules
WranglersWrangler-owned capabilities for their agents (role management, API access, approval workflow, platform flags)At registration and periodic review
Head of complianceMapping 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 estateAnnual
Head of internal auditSample test of attribution: agents commit under their own identity, the wrangler of record is named, and no agent service principal holds standing production accessHalf-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

FailureHow you recognise itRecovery
The catalogue treated as a build manifestA programme plan to build all 33 entries before any product ships; a new kit written beside an existing oneMap the existing kit; build only the gaps; fork published kits
Bespoke capabilities per applicationSeveral applications with their own task, comment or approval model; agents carry per-application adaptersRoute 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 runtimeThe agent’s service principal is the same identity humans use for emergency production access, or holds a broad production roleSeparate 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 onlyHealth endpoints exist but /ready never reports dependency failure; error bodies lack correlation_id; flags never expireAdd the convention as a pipeline check (architecture conformance, control 5), not a guideline
Optional kitTeams can create a repository without the kit and nothing failsMake the kit the only sanctioned template; treat out-of-kit repositories as deviations with an owner and date
AI reviewer replacing the humanFewer reviewer-requested changes after an AI reviewer is enabled; rising post-merge defectsDemote 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)

← All AI Delivery Factory guidance

On this page

  1. How to use this catalogue
  2. Why standardise the plumbing
  3. Two “four-regime” models: keep them apart
  4. Regime 1 — Identity and access
    1. Components
    2. Capabilities
  5. Regime 2 — Change and deployment
    1. Components
    2. Capabilities
  6. Regime 3 — Observability and evidence
    1. Components
    2. Capabilities
  7. Regime 4 — Foundation and interaction
    1. Components
    2. Capabilities
  8. The capability contract: agent-callable through one surface
  9. Which shared asset carries which SDLC control
  10. Run a gap analysis of your existing kit
    1. Size the work to the firm (Book 1 Ch 15 §7)
  11. Ownership
  12. Failure modes and recovery
  13. Acceptance checks
  14. Source notes and conflicts

All pages in Deliver changes →