1. A word nobody can check
Enterprise-grade appears in every request for proposal I have answered and every security questionnaire I have filled in. It appears in our own decks. It is one of those words that everyone in the room agrees on and nobody can test, which is the worst kind of word to build a company on. Ask three engineers what it means and you get three lists, each honest, each shaped by the last incident that engineer lived through.
For a long time I treated it the way most CTOs do: a posture held together by a compliance certificate, a penetration test once a year, a handful of strong engineers who knew where the bodies were, and a conviction that we were careful. That is not nothing. It is also not measurable, and a thing you cannot measure you cannot assign, schedule or defend in a diligence room.
So this year we did the unglamorous thing and wrote the word down. This piece is the method, not the result. It says nothing about where any particular system stands against the list, because that is the one part of the exercise that belongs inside the company. The method travels; the scores do not.
An adjective is a promise. A list is a contract.
2. Write the list before the audit
The order matters. If you audit first, the audit decides what enterprise-grade means, and an audit is shaped by what the auditor happened to look at. We wrote the list first, with the code closed, from three sources: what every security questionnaire we had ever received asked for, what every production incident of the last three years would have been prevented by, and what a senior engineer joining from a larger company would expect to find on day one and be surprised not to.
Ours runs to 313 items in ten categories: security and identity; data and database; reliability and scalability; API and integration; DevOps, delivery and observability; engineering practice and quality; frontend and user experience; communications and product operations; compliance, privacy and governance; and AI and large language models. The last category did not exist in anyone's checklist two years ago and is now where the newest failure modes live.
The discipline is in the shape of an item, not the count. Each one is a sentence that can be checked: not "good logging" but "every log line carries a request id and a tenant id and never carries a secret or personal data". Each item then has four fields that took longer to fill than the item itself: what it means in two lines, so an engineer and a buyer read the same thing; how it helps the business, so nobody mistakes it for ceremony; which sub-department owns it; and which single role is accountable. An item with no accountable role is a wish.
3. Applicability is a decision
The second field that matters is applicability, and it has five values, not two. Mandatory: an enterprise customer is entitled to assume it. Recommended: a mature product has it and a buyer will ask. Optional: nice, and honestly priced as such. Not applicable to our architecture: a real answer, as long as it is written down with the reason. And team competency: a skill the people must have rather than a feature the product must have, such as threat modelling or performance profiling, which belongs on a hiring and training plan, not a roadmap.
Of our 313, 280 are mandatory or recommended. The remaining 33 are kept for the record, because the next person to ask "why don't we have X" deserves to find the answer already written rather than to reopen the debate. The temptation is to mark everything mandatory. Resist it. A list where everything is mandatory is a list where nothing is prioritised, and the team will quietly decide the priorities for you.
Applicability also changes with the architecture, and that is allowed. A control that is not applicable to a single-region deployment becomes mandatory the day a second region is signed. The list should carry that trigger in the reason, so the sales win that adds the region also adds the row.
4. Evidence: six read-only passes
Then the audit, and this is where the method changed because the tools changed. Answering 313 questions against two codebases by hand is a quarter of a senior engineer's time and the answer is stale before it is finished. We used AI coding agents in read-only mode instead: six passes, one per domain, each given the items for its domain and the repositories, each forbidden from changing anything, each required to answer every item per product with one of four values and to cite the file and line for its answer.
The four values are Full, Partial, Yet to cover, and Confirm. Confirm is the honest fourth: an item that lives in infrastructure rather than code, such as database user grants or backup schedules, which a reader of the repository cannot see and must take to the people who run the platform. Marking those Partial would be a guess, and marking them Full would be a lie.
Read-only is the rule that makes the exercise trustworthy. An agent that can edit will be tempted to fix the small things it finds, and then the evidence describes a codebase that no longer exists and a change nobody reviewed. The passes produce a dated assessment: on this day, this item, this product, this file and line. Six passes over two codebases took days, not a quarter, and the output is a table a human can spot-check in an afternoon, which we did.
I will share the shape of what such passes find without sharing ours, because the shape is universal in any codebase older than two years. Most items do not come back as missing. They come back as Partial: the control exists, built well, in the module where the engineer who cared about it worked, and is absent from its siblings. Authorisation checked in one family of resolvers and assumed in the next. Pagination capped on the lists that once fell over and open on the ones that have not yet. The list does not discover that your team is careless. It discovers that care did not propagate, which is a different problem with a different fix.
The finding is rarely absence. It is a control that never travelled.
1 · Item
A sentence you can check
What it means in two lines, why it matters to the business, whether it is mandatory, recommended, optional or not applicable, which sub-department owns it and which role is accountable.
2 · Evidence
What the code says today
Read-only review passes answer each item per codebase: Full, Partial, Yet to cover, or Confirm with the people who run the infrastructure. Every answer cites a file and line, dated.
3 · Playbook
How to get to Full here
One page per item: definition of done, the standard to adopt, the steps per stack, the day-one rule for a new app, how to verify, what proof to file, who signs off. Sized S to XL, placed in a wave.
4 · Change
The pull request names the rows
No change ships without saying which items it touches. Status and proof are updated in the same change, never in a later clean-up that does not come.
5 · Proof
Something an auditor accepts
A dated artefact per item: a test run, a screenshot, an export, a configuration dump, with secrets and personal data redacted. Evidence says the control exists; proof shows it working.
Rollout waves · ordered by dependency and blast radius, not by category
wave 0
Stop the bleeding
secrets, lockfiles, CI boot gate, health, logging, backups
wave 1
Security P0
default-deny authorisation, lockout, audit log, validation
wave 2
Data and tenancy
decimals, UTC, migrations, encryption, restore drill
wave 3
Observability and delivery
request ids, metrics, alerts, pipelines, rollback
wave 4
Reliability and scale
jobs out of the API, timeouts, retries, idempotency
wave 5
Quality, API, frontend
coverage gates, versioning, performance, accessibility
wave 6
Compliance and AI
rights, residency, guardrails, evaluation, admin tooling
Each wave has an exit criterion phrased as an outcome, not a count: nothing in the repository can open production; an external test finds no critical finding in authentication, authorisation or tenancy; a restore drill meets the stated recovery time.
5. Evidence is not proof
The passes produce evidence: the code says the control is there. A buyer's security team, an auditor and a diligence adviser all want something else, which is proof: an artefact showing the control working on a date. A test run that fails when the check is removed. A screenshot of the lockout firing. An export of the audit log with a sensitive action in it. A configuration dump with the header set. Dated, with secrets and personal data redacted, filed where the next person can find it.
We keep the two apart on purpose. Evidence is cheap to regenerate and rots fast; proof is expensive and keeps. Each item has a folder; each folder has a short note saying what proof it should contain and who owns capturing it; the items without a proof yet are a single list sorted by owner. That list is what turns a security questionnaire from a week of archaeology into an afternoon of attaching files, and it is what you hand to the diligence room instead of adjectives.
One rule for proof that took us an incident to learn: gap evidence never leaves the building. The same file-and-line detail that makes an internal assessment useful is a map for an attacker if it reaches a shared drive. Proof of a control can be shared after a redaction review. Evidence of a gap is for the people fixing it.
6. One page per item: the playbook
An item tells you what and whether. It does not tell a developer what to do on Monday. So every mandatory and recommended item gets one page, and the page has the same eight sections every time: the definition of done, written as observable facts rather than intentions; where we stand today, carried over from the evidence; the standard to adopt, which is one table of values, not a discussion; the steps per stack, because the Node backend, the React application and the Python services do not share a fix; the day-one rule for any new application, so the next service starts at Full; the pitfalls, which are the ways this exact fix has gone wrong before; how to verify it yourself; and which proof to file and who signs off.
Each page is sized once, with four values: under a day, under a week, under a month, or a programme. That sizing is what lets the list meet a roadmap. Three hundred items is not a plan. Three hundred items with an owner, a size and a position in a wave is a plan that fits in a quarterly review.
The playbooks are written in the team's voice and the team is allowed to be wrong in them. When a page turns out not to fit the code, the rule is to fix the page in the same pull request as the fix. A playbook nobody may edit becomes a document nobody reads.
7. Waves, not categories
The categories are for reading. The order of work is not. If you roll out by category you will spend a quarter on security while the deployment pipeline still lets an untested build reach production, and the security work will be undone by the next hot fix. So the items are placed in waves by two tests: what depends on what, and what hurts most if it fails first.
Wave zero is called stop the bleeding and contains the prerequisites everything else assumes: secrets out of the repositories and rotated, lockfiles committed and installs pinned, a continuous-integration gate that builds and boots every merge, a real health check, a structured-logging baseline, backups confirmed. Its exit criterion is a sentence, not a count: nothing in the repository can open production, and every merge is built and booted by CI. Wave one is security priority zero, exit criterion: an external test finds no critical or high finding in authentication, authorisation or tenancy. Wave two is data and tenancy integrity: payroll figures reconcile to the cent and a restore drill meets the stated recovery time. Then observability and delivery, then reliability and scale, then quality and the API and the front end, then compliance, AI and product operations.
Phrasing exits as outcomes rather than as item counts is the single thing that kept the waves honest. A wave with forty-seven of fifty items done is not done if the three remaining are the ones the exit sentence depends on. The sentence refuses to let the team count its way out.
8. Ten rules for day one
Three hundred items cannot be in anyone's head. Ten can. So from the list we took the ten that every new application must have from its first commit, and made them the rule for starting anything, including a prototype that will supposedly be thrown away. Tenant isolation in every query, cache key, job, route and admin surface. Authorisation and input validation enforced on the server, never only in the interface. An audit log for sensitive actions: authentication, approvals, salary, roles, exports. Structured logging with a request id and no personal data or secrets. Pagination with a server-side maximum on every list.
Timeouts, bounded retries with backoff and idempotency on every outbound call and job. Secrets only in the environment or a vault, a committed lockfile, pinned installs, and never a forced dependency fix. Dates stored in UTC and rendered per tenant, money as decimals. Tests plus a continuous-integration boot-and-smoke gate before user acceptance. A health check, graceful shutdown and a feature flag for anything a client can see.
None of these is clever. All of them are the items that, when missing, cost the most to retrofit, because they are cross-cutting: tenant isolation added in month twelve touches every query written in months one to eleven. The reason to name ten is so that a starter repository can carry them, and a new service begins at wave one rather than at wave zero. The reason the ten are written in a file every coding agent reads before it touches the code is covered in The hardening pass: the assistant that wrote the prototype will happily write the same gaps again unless the rules are in its context.
9. The mechanism
Everything above is a document, and a document without a mechanism is shelf-ware within a quarter. The mechanism is small and it is mandatory. Every pull request names the rows it touches. If a change closes a gap, the status moves and the proof is filed in the same change, never in a clean-up that comes later, because it does not come later. If a change opens a gap, which happens, the row moves the other way, and the reviewer sees it move.
Around that rule sit a few rhythms. Ten minutes a week in the engineering stand-up on what moved and what is blocked. An exception register for items we consciously defer, each with the risk, who accepted it, and an expiry date after which it must be re-accepted or fixed; a deferral with no expiry is a decision nobody owns. A quarterly re-run of the six evidence passes, because evidence rots and the list is only true on the day it was checked. And a trend line: Full, Partial and Yet to cover counted at every build and charted, so progress is visible without anyone being asked for a status.
The quiet effect of the mechanism is on conversations. A request from sales for a feature now arrives with the question of which rows it touches. A security questionnaire is answered from the proof folders rather than from memory. A diligence question about engineering maturity gets a list, a trend and a set of dated artefacts instead of a confident paragraph.
10. What it does not do
The read-only passes read code. They do not see the cloud console, the network policy or the on-call rota, and the Confirm status exists precisely so the list does not pretend they do. The infrastructure items need people, and those conversations are slower than any agent.
A list is only as good as its evidence, and evidence is only as good as the spot-check. We checked a sample of every pass by hand and found the agents conservative rather than generous, which is the right direction to be wrong in, but it is still a sample. Anyone who ships the output of a code review agent as an audit without reading it has replaced one unverified adjective with another.
The number of mandatory items must stay honest, or the list becomes a bureaucracy that engineers route around. And the method does not make a system enterprise-grade. It makes the distance visible, assigns it, sizes it and tracks it. The work is still the work. What changes is that the word on the slide now points at something a stranger could check, and a team that can be checked behaves differently from one that can only be trusted.
A list is only true on the day you checked it. So check it, and write the date down.
The pass that applies these rules to a single prototype is The hardening pass; the migration that first taught us how controls fail to travel between modules is Two migrations; the catalogue of what exists, kept deliberately separate from this list of what must exist, is in The product bible; and the AI category of the list has its own write-up in What we let the HR assistant answer, and what we don't.