How-to
SOC 2 Compliant Software Development: A How-To
Table of Contents
- What SOC 2 Compliance Means for Software Development
- The Five Trust Services Criteria and How They Apply to Your Code
- Step 1: Assess Your Current State with a Readiness and Gap Assessment
- Step 2: Implement SOC 2 Change Management Process for Code and Infrastructure
- Step 3: Establish SOC 2 Code Review Requirements and Access Control
- Step 4: Build SOC 2 Evidence Collection into Your Development Workflow
- Step 5: Select and Deploy SOC 2 Compliance Software for Automation
- Common Engineering Audit Failures and How to Avoid Them
- Frequently Asked Questions
Last Updated: October 20, 2026
What SOC 2 Compliance Means for Software Development
SOC 2 compliant software development means baking security controls, audit trails, and documentation into every phase of your process, not checking a box at the end.
It changes how your team writes code, reviews changes, logs events, and responds to incidents.
This guide covers the five Trust Services Criteria, five steps to implement SOC 2 controls, and common audit mistakes.
The Five Trust Services Criteria and How They Apply to Your Code
SOC 2 rests on five Trust Services Criteria, each mapping to decisions your engineering team makes daily.
Security, Availability, Processing Integrity, Confidentiality, and Privacy
Security means your systems resist unauthorized access, access control, authentication, encryption, and monitoring.
Availability means uptime plus disaster recovery, business continuity, and failover, with backup systems and recovery time objectives.
Confidentiality means protecting sensitive data through encryption in transit and at rest, role-based access, and data classification.
Step 1: Assess Your Current State with a Readiness and Gap Assessment
A readiness assessment maps your current controls against the five Trust Services Criteria; a gap assessment shows what's missing.
Document findings honestly, many teams discover they have controls in place but no formal process around them. A gap assessment typically takes 2-4 weeks for a small team, longer for larger organizations.
Step 2: Implement SOC 2 Change Management Process for Code and Infrastructure
SOC 2 change management means every code or infrastructure change is tracked, approved, tested, and documented. CC8.1, the common change-management criterion, sounds like bureaucracy until you map it to tools engineers already use.
Don't build a parallel compliance process. Attach each control to a point in your existing pull-request and pipeline workflow, assign an owner, and capture evidence automatically.
Map controls to the pull request lifecycle
| Control intent | Where it lives | Owner | Evidence artifact |
|---|---|---|---|
| Changes are authorized | Pull request description with linked ticket | Author | PR with linked issue ID and business justification |
| Changes are reviewed | Required reviewer rule on protected branch | Reviewer | PR approval record with reviewer identity and timestamp |
| Segregation of duties | Branch protection blocks self-merge | Platform/DevOps | Branch protection configuration export |
| Changes are tested | Required status checks (unit, integration, security scan) | Author + CI | CI run log attached to the commit SHA |
| Changes are deployed through a controlled pipeline | CI/CD deployment job, no manual production pushes | DevOps | Deployment log with commit SHA, environment, approver, timestamp |
| Rollback is possible | Documented rollback runbook and prior release artifact | DevOps | Runbook version history and last rollback test record |
Four of these six controls can be enforced mechanically through branch protection and required status checks, removing the temptation to skip them under deadline pressure.
Pull request controls that auditors actually test
Auditors sample changes and ask three questions: was it authorized, reviewed by someone other than the author, and tested before production. Configure your repository so the answer is provable without a screenshot:
- Protected main branch. Require at least one approving review, dismiss stale approvals on new commits, and block direct pushes. Export the branch protection settings quarterly as evidence.
- Required status checks. Make unit tests, dependency scanning, and static analysis required to merge, a failed check should block the merge button, not just notify.
- Linked work item. Require a ticket reference in the PR so the business reason is traceable.
CI/CD pipeline controls
The pipeline makes change management continuous. A common pattern is a four-stage pipeline with a gate at each stage:
- Build. Compile and produce an immutable artifact tagged with the commit SHA. Evidence: build log.
- Test. Run automated tests and a software composition analysis scan. Fail the build on critical vulnerabilities. Evidence: test report and scan output.
- Approve. For production, require a manual approval by a designated release owner. Evidence: pipeline approval record with approver identity and timestamp.
- Deploy. Deploy the exact artifact that passed testing, no rebuilds between environments. Evidence: deployment log mapping artifact SHA to environment and time.
Artifact promotion is the strongest change-management control because it proves what was tested is what shipped.
Infrastructure as code
Infrastructure changes should follow the same path as application code. Use Terraform, CloudFormation, or equivalent, and require every change to go through a pull request with plan output attached.
- Store infrastructure in version control with the same branch protections as application code.
- Require the
planoutput to be posted to the pull request so reviewers see exactly what will change before approval. - Restrict who can run
applyagainst production, and log every apply with the operator identity and commit SHA.
Rollback and emergency changes
Auditors accept emergency changes, not undocumented ones. Define an emergency change path in advance:
- A named approver (or on-call lead) who can authorize a hotfix outside normal review.
- A requirement that the change still be reviewed retroactively within one business day.
- A ticket that records the incident, the change, and the follow-up review.
Run a rollback drill at least quarterly and keep the results, a dated drill record answers "how do you know rollback works" in seconds.

What to hand the auditor
Your change-management evidence package should include branch protection exports, sampled pull requests with approvals and linked tickets, CI/CD definitions and deployment logs, infrastructure plan-and-apply records, the emergency change policy, and rollback drill results.
Step 3: Establish SOC 2 Code Review Requirements and Access Control
Code review is your first line of defense and one of your strongest audit artifacts. Auditors want to see that code was reviewed before it shipped.
Identity Management and Least Privilege
Access control starts with identity management: unique accounts for every engineer, no shared credentials, no "admin" accounts for daily work.
Least privilege means each engineer has access only to what they need, frontend engineers don't need production database access.
Review access quarterly, and remove access when people change roles or leave.
Ready To Talk About Your Application →
Code Review Workflows and Documentation
Require code review before every merge to main branches.
Store code reviews in your version control system. They become your audit trail.
Step 4: Build SOC 2 Evidence Collection into Your Development Workflow
Auditors grade evidence, not intentions. Teams that pass cleanly treat evidence as a build artifact, generated automatically, stored in a known location, retained for the audit period, rather than scrambling three weeks before fieldwork. For each artifact below, know what it is, where it lives, how often it's collected, and who owns it.
The engineering evidence catalog
| Evidence artifact | What it proves | Where to store it | Collection cadence | Owner |
|---|---|---|---|---|
| Branch protection configuration export | Changes require review and status checks | Compliance evidence bucket or GRC tool | Quarterly, plus on change | Platform/DevOps |
| Pull request sample with approvals | Changes were reviewed by a non-author | Version control system (native) | Continuous; sample pulled at audit | Engineering managers |
| CI/CD pipeline definitions and deployment logs | Changes were tested and deployed through a controlled path | CI/CD system, exported to evidence store | Per deployment; monthly export | DevOps |
| Infrastructure plan/apply records | Infrastructure changes were reviewed and authorized | Version control plus CI logs | Per change; monthly export | Platform/DevOps |
| Access review sign-offs | Least privilege was reviewed and enforced | Identity provider export plus GRC tool | Quarterly | Security lead |
| Vulnerability scan results and remediation tickets | Vulnerabilities were identified and fixed within SLA | Scanner dashboard plus ticketing system | Weekly scan; monthly summary | Security engineer |
| Incident response records | Incidents were detected, contained, and remediated | Ticketing system | Per incident; quarterly summary | Security lead / on-call manager |
| Backup and disaster recovery test results | Recovery procedures work | Runbook repository plus test log | Quarterly | DevOps |
| Security awareness training completion | Personnel completed required training | HR or learning platform | Annually, plus new hires | HR / People ops |
| Onboarding and offboarding access records | Access was granted and revoked in a controlled way | Identity provider plus HR system | Per event; quarterly reconciliation | HR plus IT |
Designate one evidence store, a dedicated, access-controlled bucket or a GRC platform, and make every automated export land there with a consistent naming convention (control ID, artifact type, date). When the auditor asks for CC8.1 evidence, filter by control ID and hand over the folder.
Make collection automatic
Manual evidence collection fails because it competes with shipping. Automate the high-frequency artifacts first:
- Scheduled exports. Use CI/CD and cloud provider APIs to export deployment logs, access logs, and configuration snapshots to the evidence store.
- Webhook-driven capture. Trigger an evidence record when a production deployment, access change, or incident ticket is created.
- Screenshot-free proof. Prefer machine-generated exports (JSON, CSV, configuration files) over screenshots, which are hard to verify and easy to fake.
Logging and monitoring as evidence
Your application and infrastructure logs are evidence of processing integrity, security monitoring, and incident detection:
- Centralize logs in a log aggregation service with access controls and retention aligned to your evidence policy.
- Log security-relevant events, authentication successes and failures, authorization decisions, sensitive data access, configuration changes, and administrative actions.
- Protect log integrity with append-only storage or write-once retention.
Incident response records
Every incident should produce a record answering: what happened, when was it detected, who responded, what was the impact, how was it contained and fixed, and what changed afterward. Store these in your ticketing system with a consistent template, auditors sample incidents and walk the timeline, so a complete record beats a polished narrative.
AI-assisted development and open-source dependencies
Two evidence areas are increasingly requested and rarely covered by generic guides:
- AI-generated code review. If engineers use AI coding assistants, document that generated code still goes through the same pull-request review and testing gates. Keep the policy stating AI-generated changes are not exempt from review, and retain PR records showing review occurred.
- Dependency provenance and license checks. Maintain an SBOM generated by your build pipeline, retain software composition analysis results, and record license checks for new dependencies.
Quarterly evidence review
Once a quarter, run a 60-minute evidence review with engineering, security, and compliance. Confirm each artifact was collected on schedule, spot-check that the data is readable and complete, and note gaps with an owner and due date. This review itself becomes evidence that your controls operated throughout the period, exactly what a Type II report demonstrates.
Step 5: Select and Deploy SOC 2 Compliance Software for Automation
Manual compliance is fragile. Automate what you can. Compliance software helps you track controls and evidence, generate audit reports, manage risk assessments, automate policy distribution, and monitor continuous compliance.
Our hybrid approach to SOC 2 compliant software development includes compliance automation from day one, so your team focuses on shipping secure code, not scrambling to document compliance later.
Common Engineering Audit Failures and How to Avoid Them
Most audit failures come from the same mistakes:
Missing code review documentation. Fix: require pull request reviews in GitHub/GitLab and never merge without documented approval.
No access control audit trail. Fix: use identity management software, document role assignments, and review quarterly.
Infrastructure changes not tracked. Fix: use infrastructure-as-code, require approval for all infrastructure changes, and log everything.
Logging turned off in production. Fix: enable logging everywhere, archive logs, and make them tamper-proof.
No disaster recovery testing. Fix: test disaster recovery quarterly, document results, and show auditors proof.
Ready to talk about your application? Our hybrid team of US-based leaders and certified engineers integrates compliance into your development workflow, so you ship secure code faster. Ready To Talk About Your Application
Frequently Asked Questions
How hard is it to get SOC 2 compliant?
Difficulty depends on your starting point and team size. A readiness assessment typically identifies gaps within 2-4 weeks. Implementation takes 3-6 months for most mid-size teams, assuming dedicated ownership and automation tools. The hardest part is not the controls themselves but establishing consistent evidence collection and audit trails across development, operations, and security. Organizations that automate logging, code review, and access tracking see faster results than those relying on manual processes.
What are the five principles of SOC 2?
SOC 2 is built on five Trust Services Criteria: Security (protecting systems and data from unauthorized access), Availability (ensuring systems are accessible when needed), Processing Integrity (transactions are complete, accurate, and timely), Confidentiality (sensitive data is restricted to authorized parties), and Privacy (personal data is collected, used, and retained appropriately). Your software development process must address all five, though Security, Availability, and Processing Integrity typically require the most engineering effort.
How should developers document changes for SOC 2?
Every code change, infrastructure modification, and access grant must have an audit trail. Use version control systems (Git) with enforced commit messages, require code review approvals before merge, log all deployments with timestamp and actor, and maintain change request records linking business justification to technical implementation. Automated logging tools capture this evidence; manual spreadsheets are audit red flags. Document not just what changed, but who approved it, when, and why.
Which software development controls are commonly reviewed in a SOC 2 audit?
Auditors focus on access control (who can commit, deploy, and access production), change management (how code and infrastructure changes are approved and tested), code review (peer review before deployment), vulnerability management (scanning and remediation), incident response (how security issues are detected and resolved), and logging (audit trails of all system activities). They also examine secure development practices like secure coding standards, dependency management, and testing protocols. Evidence must show these controls operated consistently during the audit period.