Skip to content
Stribog

Compliance

All writing

AICPA SOC 2 Guide: The System Description Sets the Scope

The AICPA SOC 2 guide and DC 200 decide what a system description must disclose. On a self-hosted platform, generate it from inventory and keep it true.

Stribog16 min read

Most SOC 2 effort goes into controls and evidence. The system description gets written last, in a document editor — and then quietly decides what everything else applies to. Leave a namespace out and its controls are out. Imply a component that does not exist and the description fails its own criteria.

This article is the service organisation's side: authoring the description against the AICPA's criteria and keeping it true. Controls and evidence are in SOC 2 on self-hosted Kubernetes; reading someone else's finished report is in SOC 2 reports: reading a vendor's exceptions and CUECs.

What the AICPA SOC 2 Guide Asks of the System Description

Two AICPA documents matter. The SOC 2 guide, "updated as of October 15, 2022," tells auditors how to perform and report on the examination. The description criteria, known as DC section 200, say what the description must contain. In the 2018 text's own words, they "are to be used when preparing and evaluating the description of the service organization's system": management prepares against them, the auditor evaluates against them.

The AICPA's current edition is titled "2018 SOC 2® Description Criteria (With Revised Implementation Guidance – 2022)." According to Baker Tilly, the description criteria and the trust services criteria have not changed since 2018 and 2017; the 2022 update revised the points of focus to provide further clarity and guidance of the Trust Services Criteria. The criteria below are quoted from the 2018 text.

There are nine. DC 1 is "the types of services provided"; DC 2 "the principal service commitments and system requirements"; DC 3 the components of the system — "a. Infrastructure b. Software c. People d. Procedures e. Data". DC 4 covers identified system incidents that resulted from controls not suitably designed or operating effectively, or that otherwise caused a significant failure to achieve one or more service commitments and system requirements — disclosing the nature of each incident, its timing, and its extent or effect and disposition. DC 5 is the applicable trust services criteria and the related controls; DC 6 complementary user entity controls; DC 7 subservice organisations; DC 8 "any specific criterion of the applicable trust services criteria that is not relevant to the system and the reasons it is not relevant"; DC 9 significant changes during the period.

The examination type changes what the description is held to. In the guide's 2018 edition a type 1 report addresses the description and the suitability of design of controls as of a point in time. A type 2 adds "whether controls operated effectively throughout the period of time" and the auditor's tests and results. DC 4 follows suit — incidents as of the description date for a type 1, during the period for a type 2 — and DC 9 applies only to a description covering a period.

Commitments and requirements are inputs, not prose to invent. The 2018 guide says commitments can be communicated in "written individualized agreements, standardized contracts, service level agreements, or published statements", and requirements are often specified in "policies and procedures, system design documentation, contracts with customers, and in government regulations." All of those already live somewhere you control.

The Boundary Is the Scope: Five Components and What Sits Outside

DC 200 defines the boundaries of a system as "the specific aspects of a service organization's infrastructure, software, people, procedures, and data necessary to provide its services." When systems share components, "the systems will overlap, but the boundaries of each system will differ." A shared Kubernetes cluster serving two products is two overlapping systems with two boundaries, not one.

The 2018 SOC 2 guide sets a floor by category:

  • Security, availability or processing integrity. The boundary covers "at a minimum, all the system components as they relate to the transaction processing or service life cycle including initiation, authorization, processing, recording, and reporting of the transactions processed for or services provided to user entities." The same 2018 passage then draws the other edge: the boundary would not include the instances in which that transaction-processing information is combined with other information for secondary purposes internal to the service organization, such as customer metrics tracking. The secondary-use instance is excluded, not the information: the transaction life cycle that produces those records stays inside the boundary. A product-analytics pipeline that reuses those records for internal reporting is not pulled in merely because it reads them. An observability namespace can still be in scope for availability — the exclusion turns on the secondary internal use, not on which namespace holds the data.
  • Confidentiality or privacy. The boundary follows the information life cycle — "collection, use, retention, disclosure, and disposal or anonymization" — and explicitly includes "informal ad hoc procedures." The guide's own example of an informal ad hoc procedure is emailing personal information to an actuary. By the same logic, an engineer's one-off export of that information to a laptop is inside the boundary whether or not anyone wrote it down — this is an illustration, not a rule that every export is in scope. Note that the secondary-use exclusion above does not carry over: for confidentiality or privacy, the 2018 guide includes the instances in which that information is combined with other information, without pulling the other information itself into the examination.

The component definitions are wide. Infrastructure includes "facilities, servers, storage, environmental monitoring equipment" and "internal networks and connected external telecommunications networks." People means "the personnel involved in the governance, management, operation, security, and use of a system", vendor personnel included. On a self-hosted platform that reaches the colocation cage, the uplinks and the on-call rota.

Some functions can sit outside. The 2018 DC 200 implementation guidance says the description "needs to clarify which processes or functions are included in the examination," and lists three functions at the service organisation that may be outside the boundary of the system being described: the process used to invoice user entities, the conversion of new user entities onto the service organisation's systems, and the receipt of data from sources outside the system. Its example of the third is a payroll processor whose inputs arrive from the employer in a ready-to-process state, which limits the described system's responsibility to processing those inputs; the receipt function itself may be declared outside. For a self-hosted platform with an ingestion edge, that makes the boundary at intake a decision to state explicitly, not a default in either direction. Excluding is allowed; leaving readers to guess is not. The same discipline appears in PCI DSS, where audit scope is an evidence problem before it is a network one, and in ISO 27001, where the ISMS scope statement does the same job.

Three Systems of Record, One Description

The criteria prescribe no format. The 2018 guidance says "there is no prescribed format for the description" and that "flowcharts, matrixes, tables, graphics, context diagrams, or a combination thereof" may supplement the narrative. If format is free, content can be generated. Stribog's engineering recommendation — not an AICPA requirement — is to give each DC 3 component one owning system of record:

  • Software → the Kubernetes API. What runs, where, from which image.
  • Infrastructure → NetBox. It combines IP address management and data-centre infrastructure management, and NetBox Community is "the free, open source edition, which you deploy and manage yourself." It holds the physical half the cluster API cannot see.
  • People → the Backstage catalog. It "keeps track of ownership and metadata for all the software in your ecosystem," built from "metadata YAML files stored together with the code." Every component, resource and system carries a required spec.owner reference — a group by default, or a user — so accountability for each component becomes a query. That owner field is a pointer, not the DC 3 people disclosure, which covers everyone involved in governance, operation, security and use, vendor personnel included.
  • Procedures and data → a policy repository. None of the three covers runbooks or data classification; keep them as reviewed markdown and tagged catalog resources.

Backstage models the grouping. A System "is a collection of resources and components," and a Resource "describes the infrastructure a system needs to operate," such as a database. Declare the described system once; components and data stores point at it:

yaml
# catalog-info.yaml: the described system, one service, its data store.
# The "confidential" tag is your own data-classification convention.
apiVersion: backstage.io/v1alpha1
kind: System
metadata:
  name: ledger-platform
  description: Hosted ledger API, the system described in the SOC 2 report
spec:
  owner: group:platform-team
---
apiVersion: backstage.io/v1alpha1
kind: Component
metadata:
  name: ledger-api
spec:
  type: service
  lifecycle: production
  owner: group:ledger-team
  system: ledger-platform
  dependsOn:
    - resource:ledger-db
---
apiVersion: backstage.io/v1alpha1
kind: Resource
metadata:
  name: ledger-db
  description: PostgreSQL cluster holding customer ledger entries
  tags: [confidential]
spec:
  type: database
  owner: group:ledger-team
  system: ledger-platform
Ownership feeds the people component; the Resource and its tag feed the data component. All three tools are open source and self-hostable.

Deriving the Description from the Inventory

Systems of record answer "what exists." The boundary answers "what is described," and needs a home too: a version-controlled manifest. The schema is a convention to adapt, not a standard; the platform is fictional:

yaml
# system-boundary.yaml: your own convention, not an AICPA schema.
# Changed only by pull request; the generator and drift check read it.
system: Example Ledger Platform # fictional
report_type: type2
period: { start: 2026-01-01, end: 2026-12-31 }
categories: [security, availability, confidentiality]

services: # DC 1
  - Hosted ledger API for user entities
  - Monthly statement export to user entities

commitment_sources: # DC 2: where commitments and requirements are written
  - contracts/master-services-agreement.md
  - contracts/service-level-agreement.md
  - policies/security-practices-statement.md

in_scope: # DC 3 software and infrastructure, by system of record
  clusters:
    - context: prod-eu-1
      namespaces: [ledger-api, ledger-worker, ledger-db, ingress, cert-manager, observability]
  netbox_sites: [fra-colo-1]
  backstage_system: ledger-platform

platform_namespaces: # Kubernetes' own namespaces: in scope, declared, never implied
  - kube-system
  - kube-public
  - kube-node-lease
  - default

out_of_scope:
  functions: # clarified so report users are not confused about scope
    - Invoicing user entities (separate billing system)
    - Conversion of new user entities onto the platform
  namespaces:
    - name: billing-sync
      reason: Invoicing integration, outside the described system
    - name: sandbox
      reason: Engineer sandbox; no customer data, network policy deny-all

subservice_organizations: # DC 7
  - name: Example Colocation GmbH # fictional
    service: Data-centre space, power, cooling, physical access
    method: carve-out
    csocs:
      - Physical access to the cage is restricted to authorised personnel and logged.
    monitoring_controls: # our controls that monitor theirs
      - Annual review of the operator's SOC 2 report and exceptions by the security lead.
      - Quarterly reconciliation of the cage access list against current staff.
  - name: Example Registrar Inc. # fictional
    service: Domain registration and authoritative DNS
    method: carve-out
    csocs:
      - Changes to the registrar account require multi-factor authentication.
    monitoring_controls:
      - Daily automated comparison of live NS and DS records against the declared zone.

cuecs: # DC 6
  - User entities restrict their API keys to authorised personnel and revoke them on staff departure.
One file carries the inputs for DC 1, the DC 2 sources, the DC 3 scope, the exclusions, DC 6 and DC 7: each carved-out subservice organisation lists its CSOCs and, separately, the service organisation's own controls that monitor them. The narrative the description needs is still written by people. Kubernetes' own namespaces are listed explicitly rather than silently skipped.

Then pull the software and node inventory for in-scope namespaces straight from the API. The script names the resource types it wants — kubectl get deployments,statefulsets,daemonsets,cronjobs -A -o json — because -A only widens a typed request to every namespace; -o json makes the result machine-readable, and jq keeps only what the manifest declares:

bash
#!/usr/bin/env bash
# Inventory the in-scope software and nodes of one cluster as description evidence.
# Usage: ./inventory.sh prod-eu-1 > evidence/inventory/prod-eu-1-$(date -u +%F).json
set -euo pipefail

CTX="${1:?usage: inventory.sh <kube-context>}"
BOUNDARY="${BOUNDARY:-system-boundary.yaml}"

# In-scope namespaces for this context, plus the declared platform namespaces.
NS=$(python3 -c '
import json, sys, yaml
b = yaml.safe_load(open(sys.argv[1]))
ns = [n for c in b["in_scope"]["clusters"] if c["context"] == sys.argv[2] for n in c["namespaces"]]
print(json.dumps(ns + b.get("platform_namespaces", [])))
' "$BOUNDARY" "$CTX")

WORKLOADS=$(kubectl --context "$CTX" get deployments,statefulsets,daemonsets,cronjobs -A -o json |
  jq --argjson ns "$NS" '
    [.items[]
     | select(.metadata.namespace | IN($ns[]))
     | (.spec.template.spec // .spec.jobTemplate.spec.template.spec) as $pod
     | {namespace: .metadata.namespace, kind, name: .metadata.name,
        images: ([($pod.containers + ($pod.initContainers // []))[].image] | unique)}]
    | sort_by(.namespace, .kind, .name)')

NODES=$(kubectl --context "$CTX" get nodes -o json |
  jq '[.items[] | {name: .metadata.name,
        kubelet: .status.nodeInfo.kubeletVersion,
        os: .status.nodeInfo.osImage,
        runtime: .status.nodeInfo.containerRuntimeVersion}]')

jq -n --arg ctx "$CTX" --arg at "$(date -u +%FT%TZ)" \
  --argjson workloads "$WORKLOADS" --argjson nodes "$NODES" \
  '{cluster: $ctx, generated_at: $at, nodes: $nodes, workloads: $workloads}'
Read-only, explicit --context on every call. CronJobs keep their pod spec one level deeper, hence the fallback. Needs kubectl, jq 1.6+ and PyYAML. A mistyped context matches no in_scope entry and still yields platform-only output, so run the drift check below first — it exits 1 on an unknown context.

Commit the dated output as evidence and render the description's software section from it, grouped by Backstage component with the owner beside each row. Bare pods with no controller do not appear — itself worth a question. Cluster-scoped objects that shape the system, such as admission policies, belong in the same evidence set; kubectl api-resources --namespaced=false lists the types.

Do the same for infrastructure from NetBox and people from the catalog. The description stays narrative where judgement is needed and becomes generated tables where the answer is a fact. Across many clusters it scales the way multi-cluster GitOps does: one manifest entry and one job per cluster context.

Each description section has one owning source. Carved-out subservice organisations and declared exclusions sit outside the boundary but are still written down.

Subservice Organisations When You Run Your Own Stack

Self-hosting shrinks the list of subservice organisations; it does not empty it. The test is whether an organisation's controls are necessary, in combination with yours, to meet your commitments — not whether you pay it. Candidates to judge against that test:

  • Colocation. If the facility operator controls the cage door, your physical security depends on them.
  • Hardware support. A vendor that swaps failed disks on site touches media holding customer data.
  • DNS registrar. A hijacked domain breaks availability and, via certificate issuance, security.
  • Upstream image registries. Software you did not build — unless you mirror and pin it, which may take the registry off the list.
  • An external identity provider, if workforce sign-in runs through one.

DC 7 then forces a choice of method. Under the inclusive method, in the 2018 DC 200 text, "the relevant aspects of the subservice organization's infrastructure, software, people, procedures and data are considered part of the service organization's system," and the portions attributable to the subservice organisation "would be separately identified in the description." That has a cost: under the inclusive method the subservice organisation's controls are subject to the service auditor's examination procedures, and because its components are in the description, they are in the scope of the examination. Choose inclusive for a colocation operator or DNS provider and their controls come inside the examination alongside yours. Under the carve-out method they stay outside, and the 2018 text says the description lists complementary subservice organization controls (CSOCs): controls management "assumed, in the design of the system, would be implemented by subservice organizations" and that are necessary in combination with its own. The description must also identify the nature of the services the subservice organisation performs and the controls at the service organisation used to monitor the effectiveness of the subservice organisation's controls. In the manifest's fictional illustrations those controls are reviewing the colocation operator's SOC 2 report, reconciling its cage access list and comparing the registrar's live DNS records against the declared zone; they are this article's examples, not the 2018 text's list. Carve-out is not a hand-off; it is a claim that you watch the party you carved out.

CUECs under DC 6 are the same idea pointed at customers: controls management "assumed, in the design of the system, would be implemented by user entities." Write both so a user auditor can test them. "Customers are responsible for security" is untestable; "user entities revoke API keys on staff departure" can be evidenced — and it is a CUEC only if the design actually depends on customers doing it. DC 200 treats user entity responsibilities as a different category: disclosing the responsibilities themselves is usually not practical, so management ordinarily identifies the types of communications used to convey them. Its CC 6.2 example is the boundary case — identifying authorised users and communicating that list to the service organization are not CUECs. How those lists read from the receiving end is in the vendor-report reading guide.

Keeping It True Between Examinations

A type 2 description covers a period, and the system moves during it. DC 9 asks for "the relevant details of significant changes to the service organization's system and controls during that period"; DC 4 asks for incidents that met its threshold. Both have natural sources: merged pull requests and incident records tagged with the commitment they threatened. Query them at period end; do not reconstruct from memory.

The boundary drifts fastest: a team creates a namespace and the manifest never hears about it. A small CI check catches that before the auditor does:

python
#!/usr/bin/env python3
"""Fail CI when the live cluster and system-boundary.yaml disagree.

Usage: kubectl --context prod-eu-1 get namespaces -o json > namespaces.json
       python3 check_boundary.py system-boundary.yaml namespaces.json --context prod-eu-1
"""
import argparse
import json
import sys

import yaml


def declared(boundary, context):
    in_scope = set()
    for cluster in boundary.get("in_scope", {}).get("clusters", []):
        if cluster.get("context") == context:
            in_scope.update(cluster.get("namespaces", []))
    platform = set(boundary.get("platform_namespaces", []))
    excluded = {ns["name"] for ns in boundary.get("out_of_scope", {}).get("namespaces", [])}
    return in_scope, platform, excluded


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("boundary")
    parser.add_argument("namespaces_json")
    parser.add_argument("--context", required=True)
    args = parser.parse_args()

    with open(args.boundary) as fh:
        boundary = yaml.safe_load(fh)
    with open(args.namespaces_json) as fh:
        live = {item["metadata"]["name"] for item in json.load(fh)["items"]}

    in_scope, platform, excluded = declared(boundary, args.context)
    if not in_scope:
        print(f"no in_scope entry for context {args.context}")
        return 1

    described = in_scope | platform
    findings = []
    for ns in sorted(described & excluded):
        findings.append(f"CONFLICT   {ns}: declared in scope and excluded")
    for ns in sorted(live - described - excluded):
        findings.append(f"UNDECLARED {ns}: add to in_scope or out_of_scope with a reason")
    for ns in sorted(described - live):
        findings.append(f"MISSING    {ns}: declared but absent; DC 9 significant-change candidate")

    for line in findings:
        print(line)
    if findings:
        return 1
    print(f"ok: all {len(live)} namespaces in {args.context} are accounted for")
    return 0


if __name__ == "__main__":
    sys.exit(main())
Standard library plus PyYAML. Run against a cluster with an extra tenant-x namespace and no ledger-db, it prints one UNDECLARED and one MISSING line and exits 1.

Kubernetes' own namespaces are declared in platform_namespaces, not special-cased in code, so dropping one is a reviewed change. A MISSING line is not automatically a DC 9 entry — significance is a judgement — but it forces that judgement into a pull request, with a name and date on it.

Know the limits. The check compares namespaces, not workloads; a new service in an in-scope namespace passes silently, which is why the inventory diff gets read too. Nor can it tell you an excluded namespace should have been in scope.

How Much to Disclose: the Hostile-Party Limit and Puffery

Generated does not mean exhaustive. The 2018 DC 200 guidance says disclosures "are not intended to be made at such a detailed level that they might increase the likelihood that a hostile party could exploit a security vulnerability." The inventory, with image tags and kubelet versions, is evidence for the auditor, not text for the report. The description summarises it and leaves the exploitable detail in the evidence store.

The opposite failure is the one generation prevents. The same guidance says a description is presented in accordance with the criteria when it describes the system actually "placed in operation," addresses each relevant criterion, and "does not inadvertently or intentionally omit or distort information that is likely to be relevant to report users' decisions." It is not, if it "states or implies that certain IT components exist when they do not," implies controls "when they are not being performed," or "contains statements that cannot be objectively evaluated (for example, advertising puffery)." A table rendered from the live API cannot list a Deployment, StatefulSet, DaemonSet or CronJob the API does not have. It does not prove a component is running — it still lists those objects at zero replicas or with pods not Ready, and it omits bare Pods and standalone Jobs — so read it as an inventory, not a health check. A paragraph from last year's sales deck can claim anything.

Exit Ramps and the 2027 Description Criteria

A description generated from inventory belongs to you, not to a compliance platform or an audit firm's template. Change auditors and the manifest, scripts and evidence move with you. Replace Backstage or NetBox and only the extractor changes. A second product on the same cluster is a second manifest with an overlapping boundary. The same inventory also feeds other attestations — the ISO 27001 versus SOC 2 choice and the SOC 1 versus SOC 2 choice both start from knowing what the system is.

The criteria themselves are moving. The AICPA's 17 November 2026 release says the proposed 2027 Description Criteria "retain the following nine areas" — services, commitments and requirements, components, applicable trust services criteria, CUECs, complementary subservice organization controls, criteria not applicable, significant changes and significant incidents — "while updating certain criteria and related implementation guidance." CSOCs are listed as an area in their own right. The guidance "addresses cloud computing, artificial intelligence and machine learning, APIs, and modern software architectures," emphasises enough information to understand risks "without providing so much detail that sensitive information or potential vulnerabilities could be exposed," and reinforces materiality: information "whose omission or misstatement could affect decisions made by intended users."

The news release does not quote the revised criterion text; that wording is in the exposure-draft PDF and its redlined companion. The release also gives no effective date for the Description Criteria. The companion proposed 2027 Trust Services Criteria would, if approved, apply to engagements beginning on or after 31 December 2027, with early adoption permitted; that date belongs to the TSC. When the final text lands, a team with a manifest and generators edits a template. A team with a hand-written document starts again.

§FAQ/Common questions

Frequently asked

What is the AICPA SOC 2 guide?

The AICPA's authoritative guide for performing and reporting on a SOC 2 examination of controls relevant to security, availability, processing integrity, confidentiality or privacy, updated as of October 15, 2022. What the system description must contain is set by the companion description criteria, DC section 200, which management uses to prepare the description and the auditor uses to evaluate it.

What must a SOC 2 system description include?

Under the nine description criteria: the types of services; principal service commitments and system requirements; the system's components (infrastructure, software, people, procedures and data); qualifying system incidents, with their nature, timing, and extent or effect and disposition; the applicable trust services criteria and related controls; complementary user entity controls; subservice organisations and, under the carve-out method, complementary subservice organization controls; criteria not relevant and why; and, for a type 2, significant changes during the period.

Can a function be excluded from the SOC 2 system boundary?

Yes, if the description makes the exclusion clear. The 2018 DC 200 implementation guidance gives invoicing user entities, converting new user entities and receiving data from sources outside the system as examples of functions that may be outside the boundary. What is not allowed is a description that implies components or controls that do not exist, or omits or distorts information relevant to users' decisions.

What is the difference between the inclusive and carve-out methods?

Under the inclusive method the relevant parts of a subservice organisation's system are treated as part of yours and separately identified in the description, so those components are included in the scope of the examination, and that organisation's controls are subject to the service auditor's examination procedures. Under the carve-out method they stay outside, and the description identifies the nature of the services they perform, the complementary subservice organization controls your design assumes they operate, and your own controls that monitor the effectiveness of theirs.

What changes in the proposed 2027 SOC 2 Description Criteria?

The AICPA's November 17, 2026 release says the proposal keeps nine areas, lists complementary subservice organization controls as one of them, updates certain criteria and guidance, adds guidance on cloud, AI and ML, APIs and modern software architectures, and reinforces materiality. Comments are due January 15, 2027. The release gives no effective date for the Description Criteria.

aicpa soc 2 guidesoc 2 system descriptiondc 200 description criteriasoc 2 system boundariessoc 2 description criteria 2027 exposure draftcomplementary subservice organization controls

Executive Briefing

Thirty minutes to clarify your infrastructure risk

Walk us through your vendor footprint and regulatory constraints. We will tell you honestly where sovereignty creates leverage — and where it does not. No pitch deck. No obligation.