A ledger of the nine SOC 2 Common Criteria. CC6 logical access, CC7 system operations and CC8 change management are highlighted and converge by three lines on a single gateway node labelled the server owns the state. The remaining six criteria stay dim and are marked organisational, and a dashed box below notes that the attestation itself is issued by a licensed CPA firm about an organisation over time.

What SOC 2 asks for, and what an architecture can answer

No architecture makes an organisation SOC 2 compliant, and any vendor who tells you otherwise is selling something. What an architecture decides is how expensive the evidence will be to produce — and by the time an auditor asks, that decision was made years earlier.

SOC 2 arrives the same way for almost everyone. A deal reaches procurement, a security questionnaire lands, and somewhere in it is a question that is not really a question: do you have a SOC 2 report. The team then discovers that the answer is a six-to-twelve month project, and that most of the cost lands somewhere they did not expect. Writing the policies takes a few weeks. Producing evidence for controls that were never designed to produce any takes the rest of the year.

That last sentence is what this post is about. An auditor does not accept a description of a control; they sample it and ask you to show that it operated, on specific dates, over the audit window. A control that depends on someone remembering leaves gaps. A control that is a property of the system leaves a record whether anyone remembered or not. Where you put application state turns out to decide which of those you have, for three of the nine criteria an auditor works through.

This post maps the Trust Services Criteria onto the properties of a server-authoritative architecture — precise about the three it genuinely answers, and honest about the six it does not touch at all.

First, what the report actually is

There is no such thing as a SOC 2 certificate, and nobody becomes SOC 2 certified. SOC 2 is an attestation engagement defined by the American Institute of Certified Public Accountants. A licensed CPA firm examines your controls against the Trust Services Criteria and issues an opinion. The deliverable is a report with the auditor's name on it, not a badge, and it describes your organisation during a stated period — not your software.

Type I — design, at one moment
An opinion on whether the controls are suitably designed as at a single date. It is cheaper and faster, and enterprise buyers increasingly treat it as a staging post rather than an answer. It proves you built the thing. It does not prove the thing ran.
Type II — operating effectiveness, over a period
An opinion on whether the controls actually operated effectively across an audit window, typically six to twelve months. This is the report buyers mean when they say SOC 2. It is evidence-hungry by design, and evidence that was not collected during the window cannot be produced afterwards. You cannot backfill a log you never wrote.
Five categories, one of them mandatory
Security is always in scope, and is expressed as the Common Criteria, CC1 through CC9. Availability, Processing Integrity, Confidentiality and Privacy are optional and are added to scope deliberately. Each one you add multiplies the evidence you must collect, so scope is the single most consequential decision in the whole engagement.

Two phrases are worth fixing in place before going further, because the difference between them is the difference between a true statement and a false one made to a customer. Architected to SOC 2 controls is accurate for a system built to the criteria without an engagement behind it. SOC 2 compliant, and certainly SOC 2 certified, assert a report that either exists or does not. Nothing in this post licenses the second pair.

CC6 — the criterion where architecture does the work

CC6 covers logical access: who can reach what, and whether the boundary holds. It is the criterion auditors probe hardest, because it is where breaches come from, and the probe is usually some version of the same experiment. Take an authenticated session with low privilege. Change what the client sends. See whether the server believes it.

In an application that holds state on the client, that experiment has a large surface. There is a user object in memory, a role in a token the client can read, a price in a cart, an identifier in a URL, a flag in local storage. Each of them is a claim the client makes, and every one of them must be independently disbelieved by the server. What looks like one control is really a habit, applied at every endpoint, and an auditor samples endpoints precisely because habits are applied unevenly.

Under a server-authoritative design the experiment has almost nowhere to go. The client submits intents, never state. There is no user object on the client to edit, because the client was never given one. The familiar demonstration of setting an administrator flag to true in the browser and reloading has no target — not because the flag is defended, but because it does not exist there. What the client can send is an action, and an action is a request to be judged, not an assertion to be trusted.

The second half matters as much to an auditor as the first. Because every read and every write passes through one gateway, authorisation is computed in one place. The sampling problem collapses: instead of demonstrating that forty endpoints each check permission correctly, you demonstrate one seam and show that nothing bypasses it. That is a control an auditor can test to exhaustion rather than sample.

The gateway can of course be wrong. What changes is how many things have to be right at once: one place to get right, one place to test, one place where a mistake shows. Spread the same logic across a codebase and the mistake shows only on the endpoint nobody sampled.

CC7 — evidence nobody had to remember to collect

CC7 covers system operations, and inside it sits the request that decides a great many audits: show us what happened. Not a summary, and not a dashboard — the sequence of changes, with the actor and the time, for the accounts and dates the auditor picks. Teams who have not been asked this before consistently underestimate it.

The reason it is hard in a client-heavy system is structural rather than careless. When part of the authoritative sequence is assembled on devices you do not control, the server sees results rather than causes. It records that a record now reads one way, having previously read another, with the intervening steps inferred. Reconstructing the true order of events afterwards is archaeology, and archaeology is exactly what an auditor will not accept as evidence.

A server-authoritative system does not have this problem, and does not have it because the audit trail is the storage model. State changes are events appended to a log, in order, at one gateway. Nobody added that log for compliance, so nobody could have forgotten to; it is how the application stores anything at all. Turning it off would not reduce the evidence, it would stop the product working.

3 of nine criteria answered structurally
6 still people and paper no architecture writes these
6–12 months of evidence Type II window, not backfillable

CC8 — a gate, not a promise

CC8 covers change management: that changes reaching production were authorised, reviewed and tested. An auditor will read the policy describing your process, then ask for proof that the process actually ran — including the times it stopped something.

This criterion is unusual in that it is both the cheapest of the nine to satisfy honestly and the one most often quietly fudged. The fudge is familiar: a pipeline where a slow or awkward check has been downgraded to a warning, or allowed to continue on error, so that the build stays green. Such a pipeline still produces logs. What it no longer produces is evidence, because a gate that cannot fail proves nothing about the changes that passed it.

There is nothing clever in the honest version. One script defines what a passing build means, continuous integration runs that same script rather than a copy of it, and it fails rather than warns. Every deployed version is then a commit that a gate with teeth allowed through, and the record is a by-product. None of this is specific to server-authoritative design, and it is included here only because it is the criterion a small team can satisfy this week.

An auditor is not really asking whether your system is secure. They are asking whether you can prove what it did. Those are different questions, and the second one is answered by where state lives — because a system whose state changes all pass through one place has already written the answer down, and a system whose state is scattered across clients has to go looking for it.

What the architecture does not do

Six of the nine Common Criteria are untouched by any architectural decision, and it is worth naming them rather than letting an implication do the work. CC1 wants a stated security policy with an owner. CC2 wants those commitments communicated to the people expected to keep them. CC3 wants a repeatable method for identifying and rating risks, applied more than once. CC4 wants the controls themselves monitored. CC5 wants controls selected deliberately rather than inherited. CC9 wants continuity, tested restores and a view on vendor concentration. Those are documents, meetings and habits. No architecture writes them, and a system that satisfies CC6, CC7 and CC8 perfectly while ignoring the rest fails the audit.

CC4 deserves singling out, because it is the one a very small team cannot satisfy honestly. Monitoring the controls means somebody other than the person who built them checking that they still operate. A solo maintainer reviewing their own gates is not performing that control, however diligently they do it. The answer is to say so, and to arrange a second pair of eyes, rather than to describe self-review in language that implies independence.

There is also a sting inside CC7 that this architecture does not remove. A perfect record of every state change says nothing about whether you would notice an intruder. If those logs live on the same host as the application, an attacker who reached the host can delete the only account of what they did — and evidence destruction is a scenario auditors ask about directly. Shipping logs off the box in real time is the cheapest control on this entire list and the one that cannot be backfilled afterwards. It belongs on day one, not in the month before the audit window opens.

Finally, the Availability category runs against the grain of this design rather than with it. A single authoritative server is a single point of failure, and adding Availability to the scope of an engagement invites an auditor to examine exactly that. The answer is redundancy and tested failover, both of which cost real money and real complexity. It is a genuine trade, and a site arguing for server authority should say so plainly instead of scoping the awkward category out and hoping nobody notices.

Practical advice, in the order it pays off

None of the following requires an engagement, a consultant or a budget. All of it makes a later audit cheaper, and most of it is worth doing whether or not an audit ever happens.

  • Decide whether you need it at all. Most teams pursue SOC 2 because one enterprise buyer made it a contract condition. That is a good reason. Pursuing it speculatively, before anyone has asked, spends six figures and a year of attention on a document no customer requested.
  • Scope narrowly and deliberately. Security only, one product, one environment. Every additional category multiplies the evidence you must collect and the surface an auditor examines. Scope can always be widened at the next engagement; it cannot be quietly narrowed once a customer has read the report.
  • Write four documents, one page each. A security policy with a named owner, a risk register, an incident response plan, and a continuity plan with a tested restore. One page each is genuinely enough to start, and an auditor would far rather see a short honest document that is actually used than a long borrowed one that nobody has read.
  • Make the evidence a by-product, never a task. Any control whose evidence depends on somebody remembering to take a screenshot will have gaps in the audit window, and the gaps will be in the busy months. A gate that fails the build writes its own record. So does an append-only log.
  • Ship logs off the host on the first day. It is inexpensive, it is the control that survives a compromise of the machine, and it is the one piece of evidence that genuinely cannot be produced retrospectively.
  • Start the clock before you think you need to. A Type II report describes a window that has already closed, so the useful question is not when to begin the audit but when the evidence starts accumulating. Architecture decided today is what that evidence will look like in a year.
  • Be exact about the words, including in a sales conversation. A system built to the criteria without a report is architected to SOC 2 controls. Calling it compliant or certified is a false statement to a customer, and it is the kind of statement that is checked.

The pattern underneath all seven is the same one the criteria themselves keep circling. Controls that must be remembered decay, and controls that are properties of the system do not. Where application state lives determines which kind you get for access, for the audit trail and for change — three of nine, free of charge, before anyone opens a spreadsheet. The other six are still your job, and pretending otherwise is how a green pipeline becomes a false sense of readiness.

See how the gateway works