This playbook is for one specific reader: a pre-Series-A AI startup founder or CTO with a named enterprise prospect stuck at the security questionnaire. Most of you arrived here because you've already read three or four of the underlying essays and now want them as one document: to send to the board, to a co-founder, to the head of sales, or to read end-to-end on a flight.
The playbook compiles eight essays into a single 90-day argument:
- SOC 2 is a revenue tool, not a security tool. Reframe the audit as a sales project to make the math work.
- The questionnaire. Why auto-filled answers lose enterprise deals, and what to send instead.
- vCISO math. Why fractional security leadership, typically $2–4K/month on the market, beats a $200–400K full-time CISO at this stage.
- The AI-native four-layer stack. Prompt injection, agent credentials, secrets, audit logging: the layers classic appsec doesn't cover.
- Agent secrets. Credentials that live with tools instead of the model, scoped per tool, with a kill switch.
- The LLM audit trail. What to log about model calls so the SOC 2 auditor gets evidence, not screenshots.
- What 90 days of a fractional engagement actually looks like. Week-by-week deliverables, real costs, and what graduation looks like.
- The first security hire. When to hire a security engineer, when a vCISO still fits, by stage.
Each chapter is an essay that's been published on sublimecoding.com. The web versions get edited and updated; this PDF is a snapshot. When the math changes, the source posts change too.
How to use this playbook: read the cover-to-cover argument if you're starting from scratch. Skip to a single chapter if you're already deep on one decision and want clarity on another. Send the PDF link to the person at your company who needs to hear the case made (co-founder, board member, head of sales) without having to convince them to read eight blog posts.
Chapter 1: SOC 2 is a Revenue Tool, Not a Security Tool
Start here. The single most expensive misconception about SOC 2 at pre-Series-A AI startups is that it's a security project. It isn't. It's a sales project, and that reframing changes everything about how you scope it, how long it takes, what it costs, and which engineer ends up running it. This chapter makes the case and gives you the 90-day playbook.
SOC 2 is a revenue tool, not a security tool.
Every AI founder pre-Series A gets this wrong. You scope the audit like a security project and hand it to your best engineer. Six months later you've burned your strongest IC, the report still isn't done, and the enterprise deal you were trying to close went to a competitor with the checkbox. Before scoping anything, the control triage sorts which controls are real gaps at your size and which are safe to defer.
Reframe it.
Your engineering team already thinks about auth, secrets, and data handling harder than any auditor will. SOC 2 doesn't make you secure. It unlocks the pipeline you're already leaving on the table. The VP of Engineering at that Fortune 500 who loves your demo cannot send you a contract without it.
So stop scoping it as a security project. Scope it as a sales project. And run it in 90 days.
Here's the path I've used at AI startups:
Days 1 to 30: stop the bleeding
- Pick a compliance platform (Vanta, Drata, Secureframe). Don't overthink it.
- Name one internal DRI. Not a committee. One person owns it end to end.
- Target Type I first. Type II comes after you've operated controls for 6 months.
- Retain a vCISO for 5 hours a month. $2 to 4k. Worth every dollar.
- Pull policies off the shelf from the platform. Don't write your own. Most platforms have this built in. Some are better than others.
Days 30 to 60: close the gaps
- MDM on every laptop. Non-negotiable.
- SSO and MFA across every tool, including the cheap ones nobody wants to pay to upgrade.
- Background checks on employees. 48 hours.
- Vendor review process. A spreadsheet is fine for now.
- Logging and quarterly access reviews. Most startups skip these. Auditors don't.
Days 60 to 90: get the report
- Book the audit with a reputable firm. Don't pick the cheapest.
- Run a mock audit with your vCISO two weeks before kickoff.
- Fix the 10 things they find. There will be 10.
- Get the Type I report in hand.
- This can take longer than 30 days depending on how responsive the team is to issues.
Cost and timeline
Total cost for a 15-person startup: usually $25k to $45k all in.
Timeline from kickoff to report: 90 to 120 days if you're serious.
What it unlocks
Every enterprise deal stalled at "send us your SOC 2" moves to contract. This can turn theoretical hundreds of thousands and in some cases millions in ARR pipeline into closed revenue inside a quarter.
The mistake most founders make is treating the audit itself as the security work. The audit only opens the door. The real security work starts after, once you're actually operating the controls day to day and your customer success team stops losing deals to a missing PDF.
If you're pre-Series A, AI-native, and watching enterprise deals die at the security review stage, this is the lever.
Canonical web version: sublimecoding.com/blog/soc-2-is-a-revenue-tool-not-a-security-tool
Chapter 2: Why Auto-Filled Security Questionnaires Kill AI Deals
SOC 2 gets you into the room. The questionnaire is what you face once you're in it. Most founders reach for an auto-fill tool and hand back two hundred confident answers nobody on the team wrote. This chapter covers why that reads as risk to the buyer, which dozen questions SOC 2 doesn't answer for an AI product, and how to sequence what to fix now versus defensibly defer.
TL;DR: Auto-filling an enterprise security questionnaire is the fastest way to lose the deal you were trying to win. When a review stalls, founders reach for a tool that fills two hundred fields in an afternoon, and to an experienced reviewer, that wall of auto-generated “in progress” answers reads as risk, not progress. The questionnaire isn’t a paperwork problem; it’s a proxy for “does this company actually run a security program, or did they assemble one for us last week?” The fill tool answers the wrong question fast. What actually moves the deal is a real posture you can defend under a follow-up question on a live call, especially on the AI-specific risks your SOC 2 report was never scoped to cover. Here’s what kills these deals, what actually shows up in 2026, and the honest order to build it in.
The auto-fill button is how you lose the deal
A deal you’ve spent two quarters on lands on a security questionnaire. Two hundred questions. The buyer’s procurement team wants it back by Friday. So a founder does the rational-looking thing: they buy a questionnaire-automation tool, point it at a knowledge base, and let it fill two hundred fields in an afternoon. It feels like progress. The form is complete. They send it back early, relieved.
That’s the move that kills the deal.
Here’s what the founder can’t see from their side of the table: the reviewer isn’t grading completeness. A wall of confident, generic, auto-generated “in progress” and “we are implementing” answers read as risk, not as a thorough vendor. And risk, on the desk of the person whose whole job is to keep their employer out of the next breach headline, is exactly the thing that stalls a deal, kicks it to a longer review, or ends it. (I’ll get into precisely why a moment from now.)
The questionnaire is a measurement instrument: the enterprise’s attempt to answer one question they can’t ask you directly: “if we route our customers’ data through you, how likely are we to end up in an incident report with your name in it?” Every field on the form is a proxy for that. Auto-filling your answers to a measurement instrument doesn’t change what it’s measuring. It’s a thermometer, and the fill tool is selling you a way to hold a match under it. The reading still happens, and you’ve just guaranteed it reads badly.
I’ve sat on the answering side of these as the person responsible for the program, and I’ve advised founders walking into their first enterprise review with nothing but a SOC 2 PDF and a lot of optimism. The reframe I give every one of them is the same: stop trying to complete the form and start trying to be the kind of vendor the honest answers describe. The rest of this piece is what that actually takes in 2026, starting with exactly why the fill button backfires, then the questions that decide these deals, and the honest order to build your answers in.
Why auto-fill backfires on a thin program
Now the mechanics, because “it reads as risk” deserves more than an assertion. Auto-fill questionnaire tools work by pulling from a knowledge base of prior answers and, increasingly, generating new ones with an LLM. On a mature program, that’s a genuine time-saver: you’ve answered these questions truthfully a dozen times, the answers are stable, and automation just stops you re-typing them. I have no quarrel with the category there.
On a thin program, the same tool is a tell.
Experienced enterprise reviewers read security questionnaires like a forensic document. A program that has run continuously for two years produces a particular texture of answer: specific dates, named tools, version numbers, “we adopted this in Q3 after an incident taught us X,” consistent terminology across a hundred questions, and a confidence that comes from describing something that actually exists. A program assembled the week before the review produces a different texture entirely, and the most reliable tell is a wall of “in progress,” “planned,” “we are implementing,” and vague present-tense claims that don’t survive a follow-up question.
Auto-fill amplifies the bad texture. It fills two hundred fields fast, which feels like progress, but it fills them with the average of your knowledge base: generic, confident-sounding, and frequently slightly wrong about your own systems. The reviewer asks one clarifying question on a live call: “you said you do per-tenant isolation; walk me through how”, and the generated answer collapses, because no one on your team actually wrote it. Now you’ve got a worse problem than a blank field: an answer that reads as careless or dishonest, and a reviewer who recalibrates every other answer you gave accordingly. One soft spot becomes a credibility tax on the whole document. Tenant isolation is the question auto-fill gets wrong most confidently; what isolation actually looks like in Phoenix is the answer worth having ready.
The reviewer is grading whether the answers describe a real, operating program. A blank with “we don’t do this yet, here’s the dated plan and the owner” reads as honest and self-aware. A confidently auto-filled “in progress” that crumbles under one question reads as risk. Speed is not the variable being measured, and the tools optimize for the wrong one. The deal dies because you handed a professional skeptic a reason to distrust you, faster.
The questions that actually show up
Let me split these into two layers, because the split is the whole point. The first layer is standard infrastructure and access hygiene. It has barely changed in a decade, and you genuinely need it. The second layer is the AI-specific 2026 material, and it’s where most startups get caught flat.
Standard infrastructure & access hygiene. This is the boring foundation:
- Single sign-on and MFA enforced on everything, not “available,” enforced, with no exception accounts.
- Role-based access control, least privilege, and a real offboarding process (the question behind the question: when an engineer leaves on a Friday, are their production credentials dead by Monday?).
- Encryption at rest and in transit, with someone who can actually describe the key management, not just check the box.
- A patching and vulnerability-management cadence. Who watches CVEs in your dependencies? How fast does a critical get fixed?
- Logging, monitoring, and an incident-response plan that exists as a document people have read, not a someday intention.
- Backups, tested restores, and a business-continuity story.
- Vendor / subprocessor management: every third party that touches customer data, listed, with their own security posture accounted for.
None of this is novel and none of it is optional. If you’re shaky here, fix it before you worry about anything below, because a reviewer who finds soft spots in the fundamentals will assume the fancy stuff is worse.
The AI-specific 2026 layer. This is the part that’s actually fresh, and the part that the SOC 2 PDF does not cover. In 2026, enterprise reviewers, especially at financial, healthcare, and large-tech buyers, have learned to ask AI vendors a distinct set of questions, and they’re getting sharper every quarter:
- Prompt-injection testing. If your product takes untrusted input into an LLM context (and almost every AI product does), how do you test for prompt injection? Do you have adversarial test cases? What happens when a malicious document tries to exfiltrate data or hijack a tool call? “We use a good model” is not an answer; the model is not the boundary.
- Output validation. What does your system do with model output before it acts on it or shows it to a user? Is there validation, filtering, or a schema check between the model and anything consequential: a database write, an email send, a tool invocation? Reviewers want to know you don’t treat generated text as trusted.
- Training-data and tenant isolation. Does one customer’s data ever influence another customer’s outputs? Are you fine-tuning or building retrieval indexes on customer data, and if so, is it strictly isolated per tenant? This is the question that kills deals silently: a regulated buyer will walk rather than risk their data leaking into a shared model.
- Third-party LLM usage and data-sharing terms. Which model providers do you call? What’s in their data-processing terms? Is customer data used for their training (and can you prove it isn’t)? What’s your data-retention setting with each provider? The enterprise is now your subprocessor’s subprocessor’s customer, and they know it.
- Model and data retention. How long do prompts, completions, embeddings, and logs persist? Where? Who can read them? “Indefinitely, in our logging stack, and anyone with prod access” is a real and common answer that will fail a review.
- Human-in-the-loop controls. For consequential actions, is there a human checkpoint? Can a customer configure one? What can the AI do fully autonomously, and what are the blast-radius limits if it does the wrong thing?
If reading that list made you slightly uncomfortable, good. That discomfort is the actual signal, and it’s worth far more than any auto-filled answer. These questions are where AI startups lose enterprise deals in 2026, and almost none of them are addressed by the document founders reach for first.
A supporting note: “we have SOC 2” doesn’t answer the AI questions
This point is becoming table stakes: half the vendor blogs now make it, so I’ll keep it brief. But it matters to the deal-loss story, so it earns a place here.
A founder gets the questionnaire, sees a hundred questions, and thinks: we have SOC 2, this should be covered. Then they discover SOC 2 answers maybe sixty of those questions and is conspicuously silent on the dozen the deal actually hinges on. This is a category error about what SOC 2 is, not a knock on SOC 2. A SOC 2 report attests that you met a set of controls you scoped, against the Trust Services Criteria, over a period of time. Those criteria were not written with prompt injection, model retention, or tenant isolation in a fine-tuned model in mind, and your auditor almost certainly did not test for them. The scope is whatever you and the auditor agreed to put in scope, so “we have SOC 2” tells a reviewer you have a control framework, not that the specific AI risk they care about is handled.
I’ve written before that SOC 2 is a revenue tool, not a security tool. It opens the door to the conversation but does not win it. Here’s how this connects back to deal-loss: a sophisticated reviewer accepts your SOC 2 for the infrastructure-hygiene questions, then asks, pointedly, about prompt injection and data isolation anyway, because they know those weren’t in your audit scope. If your answer to those is improvised on the spot (or auto-filled), the SOC 2 actively works against you. It set an expectation of rigor the rest of the call didn’t meet, and a reviewer who feels that gap trusts the rest of your answers less. The fix is to treat the AI layer as its own program. Running security at an AI-native company in 2026 is genuinely different from running security at a traditional SaaS company, and the questionnaire is just where that difference becomes a revenue event.
The honest sequencing: need-now vs. defensibly-defer
So what do you actually need before your first enterprise review, and what can you credibly defer? The good news for founders: you do not need a perfect program. You need a real one with honest edges. Enterprise reviewers deal with startups constantly; what they’re allergic to is pretense, not immaturity. “Not yet, here’s the dated plan and the owner” is a legitimate answer when the foundations are solid.
Here’s how I sequence it with founders. The table maps the question category to what the reviewer is really probing, and the minimum credible answer at an early stage.
| Question category | What they’re really probing | Minimum credible early-stage answer |
|---|---|---|
| Access & identity (SSO, MFA, RBAC, offboarding) | Can a single compromised or departed person reach customer data? | Non-negotiable. Enforced SSO+MFA, least privilege, same-day offboarding. Have this fully before the review. |
| Encryption & key management | Is data protected at rest and in transit by default? | Non-negotiable. In place, and someone can explain the key handling without notes. |
| Incident response | When something breaks, do they know what to do, or improvise? | A written IR plan someone has read, with named roles and a notification commitment. Tabletop it once; that’s enough early. |
| Third-party LLM data terms | Is our data training someone else’s model or persisting somewhere unknown? | Non-negotiable to know. Inventory your model providers, their retention/training terms, and your settings. Be able to state them precisely. |
| Tenant / training-data isolation | Can one customer’s data leak into another’s outputs? | Have a real architectural answer. If you don’t fine-tune or share indexes, say so plainly. That’s often the strongest answer. |
| Prompt injection & output validation | Do they treat model output as trusted? Have they tested adversarially? | Have something real: input handling, output schema checks, a few adversarial test cases. A documented, dated plan to deepen it is defensible. |
| Human-in-the-loop / autonomy limits | What’s the blast radius if the AI does the wrong thing? | Be able to state what’s autonomous vs. gated and the limits. Configurable checkpoints can be on the roadmap if named. |
| Formal certifications (SOC 2, ISO 27001, pen test) | Has a third party validated any of this? | SOC 2 Type II in progress with a date is fine pre-Series-B. A recent third-party pen test carries real weight here. |
| Vendor / subprocessor management | Do they know everyone who touches the data? | A current subprocessor list. This is cheap to do well and a soft spot here looks careless. |
The pattern: the foundations (identity, encryption, knowing your data flows) are non-negotiable and mostly cheap. The depth (mature prompt-injection testing, configurable human-in-the-loop, formal certs) can be sequenced, if you can show a dated plan and an owner, and if your foundations are genuinely solid. What you cannot do is fake the foundations and gesture at the depth. That’s the exact profile auto-fill produces, and it’s the exact profile that fails.
One more honest note on cost, because founders always ask: you do not need a full-time CISO to pass a first enterprise review, and you shouldn’t hire one yet. The vCISO math for AI founders usually points the other way at this stage: a fraction of senior security judgment, applied to exactly these questions, beats a full-time hire you can’t yet keep busy. The cost calculator sizes it against your own headcount.
One more thing about who’s telling you this
Notice something about almost every other article on this topic: it’s published by a company that sells questionnaire-automation software, and it ends in a button to buy that software. The advice can never honestly land on the conclusion this piece does, don’t reach for the fill tool, because the fill tool is what they’re selling. The conclusion is foregone, baked into the byline.
I have nothing to sell you at the bottom of this page that competes with the argument at the top. I don’t make an auto-fill tool, and the kit I do sell, linked below, works the other way: it has you write down what you actually run and marks the gaps instead of hiding them. That’s the whole reason I can tell you the auto-fill button loses deals: I have no incentive to want it to win. When you read security advice, that’s the variable to check first: what does the person telling you this need to be true? Here, it’s nothing but your program actually being good.
Before you stare down your first questionnaire
If a deal is stalled on a security review right now, resist the reflex to buy a tool and auto-fill your way out. Spend the same hour building the foundations that are non-negotiable, then answer the rest honestly, with dated plans where the program is genuinely young. Honest answers from a real foundation beat polished answers from a thin one, every time, with the reviewers who matter.
If you want to build that answer bank yourself, The AI Startup Security Questionnaire Kit has your coding agent interview you about the program you run and write each answer with its evidence, owner and gaps.
A founder shouldn’t have to navigate a first enterprise review blind. That’s the work I do as a fractional vCISO: sit on your side of the questionnaire, find the answers that won’t survive a follow-up question before the reviewer does, and build the short list of things you genuinely need first. If that’s where you are, that’s the engagement, and here’s what a fractional security engagement actually looks like once it starts.
Canonical web version: sublimecoding.com/blog/enterprise-security-reviews-ai-startups
Chapter 3: vCISO Math for AI Founders
Once you've decided to run the SOC 2 process, the next decision is who runs it on your side. Most founders default to either "I'll do it" (wrong: opportunity cost too high) or "we need a CISO" (wrong: over-leveled at this stage). The answer is fractional security leadership. This chapter walks through the math: what a vCISO costs, what they actually do, and when you graduate to a full-time hire.
Don't hire a CISO. Rent one.
This is the single most actionable security advice I give to pre-Series-A founders, and the one most consistently ignored. The pattern is predictable: an enterprise prospect asks for a SOC 2 report, the founder panics, posts a security-leadership job opening with a $250K base, sources for two months, and either hires the wrong person or gives up and ships the report without leadership in place. Both outcomes are bad. Both are avoidable.
The right answer at this stage is a fractional vCISO. Five hours a month, $2–4K, retained on a recurring contract. Below, the math, what to expect, and when to graduate to a full-time hire.
What a vCISO actually costs
Short version: a fractional vCISO runs $2–4K a month for about five hours of strategic work. A full-time CISO at a pre-Series-A startup costs $200–400K a year with benefits and overhead, before equity and a year-one recruiter fee. The full line-by-line comparison, and a calculator that sizes your own number, live on the cost page.
That is roughly 12% of the cash and none of the equity. For a pre-Series-A company where every dollar is runway, it is the difference between two months and twenty months tied up in the security function.
You might object: "But a full-time CISO does much more than 5 hours a week." That's true. They do roughly 160 hours a month. The question is: does your 15-person AI startup, which has zero customers in regulated industries, has not yet had a security incident, and is six months from its first SOC 2 audit, actually have 160 hours a month of CISO-level work to do?
It does not. It has roughly 5–20 hours a month of CISO-level work, plus a much larger volume of engineering-led security execution that the engineering team is already doing or should be doing. A vCISO sized to the actual volume of CISO-shaped work is the right tool.
What a vCISO actually does (and what they don't)
The biggest source of disappointment with vCISOs is mismatched expectations. Here's what to expect for $2–4K a month.
What they do:
- Strategic guidance. Quarterly review of your security roadmap, threat landscape, and gaps relative to your customer base. They tell you what to worry about and in what order.
- Audit and certification readiness. They read your evidence, tell you what's missing, and prep you for the auditor's conversation. Most vCISOs have shepherded ten to fifty SOC 2 audits and know exactly which controls auditors actually scrutinize.
- Customer security questionnaires. Enterprise prospects send 80–200 question security questionnaires. Your vCISO either fills them out or directs your team on the answers. This alone usually pays for the engagement.
- Incident-response support. When something goes sideways, they're on the phone in two hours. They've handled incidents before. Your engineering team has not.
- Policy authorship and review. Information security policy, acceptable use policy, vendor risk policy, incident response plan. They have templates. They customize them. They sign them. Done in days, not weeks.
- Auditor relationship. A reputable vCISO has working relationships with multiple audit firms. Their warm intro to a CPA firm gets you a faster engagement and a better rate.
What they don't do:
- Hands-on engineering. They don't write code, configure SSO, or set up MDM. Your engineering team does that under their guidance.
- 24/7 monitoring. They are not your SOC. If you need real-time monitoring, you're hiring an MSSP, not a vCISO.
- Hire and manage a security team. They might help you scope the first hire when you're ready, but they're not running people.
- Live in your Slack. Five hours a month is five hours a month. They will not be available for ad-hoc questions multiple times a day.
Match your expectations to the contract and the relationship is wildly productive. Mismatch and you'll fire each other within four months.
When to graduate to a full-time hire
The vCISO model has a ceiling. The signals that you've hit it:
- You're spending 20+ hours a month on the engagement. If you've stretched a 5-hour retainer into 20 hours of effective work, you're paying overage rates and the vCISO is bottlenecked. Time to bring it in-house.
- Your security team is more than 2 people. A vCISO can guide one or two security ICs. Beyond that, you need a security leader with capacity to actually manage.
- You're regulated. If you take on PCI Level 1, HIPAA covered-entity status, FedRAMP, or financial services charters, the regulator's expectation of a named, in-house CISO becomes binding. Hire.
- You're past Series B and selling to F500 enterprises. At that revenue scale your customer expectations include a real CISO they can put on the phone. The vCISO can no longer carry that representational load.
- You've had a security incident that drew a board-level response. Boards want a named accountable person. Don't argue with that.
Pre-Series A: vCISO. Series A through B: vCISO with the option to upgrade. Series B+: full-time, almost always.
The bad-vCISO red flags
Not all vCISOs are equal. Five flags I've learned to watch for:
- They've never been an in-house security leader. Career consultants who've never had to actually live with their decisions tend to over-prescribe. Look for someone who's been a Director or VP of Security at one or more real companies and decided to go fractional.
- They don't ask about your customers. If the vCISO doesn't immediately want to know who buys from you and what their security expectations are, they're going to give you generic advice. Your security program should be shaped by the people writing the checks, not by a checklist.
- They sell products. Some "vCISO" engagements are thinly disguised channel partnerships for compliance platforms or security tooling. They'll push you toward whatever they get paid to push. Ask up front: do you have any reseller, referral, or affiliate relationships with the platforms you'll recommend?
- They quote you "all-in flat-rate" pricing. The honest pricing is hourly with a monthly retainer minimum. Flat-rate vCISO pricing for $1,500 a month usually means you'll get attention only when you complain.
- They can't name three audit firms they'd recommend. A real vCISO has done a lot of audits and has opinions about who's good and who's bad. If they shrug at this question, they haven't done the volume.
How to interview a vCISO in 30 minutes
A short list of questions that surface signal fast:
- "What's the right SOC 2 audit firm for a 15-person AI startup?" They should name two or three with rate ranges and tradeoffs.
- "What are the three controls auditors most often flag at a company our size?" They should answer in 30 seconds without thinking. Common answers: access reviews, vendor management, change management documentation.
- "Walk me through the last incident you led." Listen for structure. Did they have a runbook? Who was in the room? What was the post-mortem? Vague answers are a flag.
- "What would you tell my engineering team to start doing on Monday?" They should have a concrete short list. If it's "depends on a deeper assessment," they're billing for the assessment.
- "What gets you fired?" Good answer: "I get fired when the auditor finds things I should have flagged in advance, or when I told you something was fine and it wasn't." Bad answer: long pause.
The deliverables to write into the contract
Don't sign a vCISO contract without specifying outcomes. Generic monthly retainers float into nothing. Concrete examples:
- SOC 2 Type I readiness in 90 days
- Information security policy + 4 supporting policies signed and ratified within 30 days
- Quarterly risk register reviewed and updated
- Customer security questionnaires turned around in 5 business days
- Incident-response participation within 4 hours of declared incident, any time
- Quarterly readout to founders / board with current posture and gap list
If they push back on writing these into the contract, they're not committing. Find a different vCISO.
The honest tradeoffs
To be fair to the full-time CISO model: there are real things you give up by going fractional.
You don't get a leader who's in your Slack every day, building relationships with engineers, customers, and the board over a sustained period. The institutional knowledge of an in-house leader compounds. They know which engineer cuts corners, which customer is going to ask which question, which board member wants which level of detail. A vCISO will never have that depth.
You also lose the recruiting halo. A named, in-house CISO with a strong reputation can be a meaningful asset when you're hiring senior security engineers or selling to security-sensitive customers. The vCISO does not show up on your team page.
And you lose the optionality of having someone in seat when things go sideways. If you have an incident on a Saturday, your full-time CISO is on it. Your vCISO is on it within a few hours, but those hours can matter.
The honest framing: the vCISO model trades depth-of-context for cost efficiency. At fifteen people pre-Series-A, the cost efficiency wins by a wide margin. The depth-of-context cost is small because there's not yet much context to be deep about. As the company grows, that math flips, and you should flip with it.
The takeaway
Your security program at 15 people, pre-Series-A, looks like:
- Engineering does the engineering security work (auth, secrets, IAM, deployment hygiene). They were doing this anyway and are better at it than any external person.
- A vCISO does the leadership, audit, and customer-facing security work. Five hours a month, $2–4K, deliverables in the contract.
- Your founder owns the customer-facing risk story until the company outgrows them.
This setup costs you $24–48K a year and 5% of the leadership burn of a full-time CISO. It unlocks SOC 2, Vendor Risk Assessments, and enterprise customer questionnaires, the unlocks that actually move revenue. And when you outgrow it, around Series B, you graduate to a full-time hire with a much clearer view of what good looks like, because you've been working with one for two years.
The mistake is treating the security leadership question as a binary "no one" or "full-time hire" problem. There's a perfectly engineered middle option, and it's the right one for the first three years of an AI-native company's life.
Want the numbers for your situation? Run them through the vCISO cost calculator. And when the math points at a fractional hire, this is exactly the engagement I run.
Canonical web version: sublimecoding.com/blog/vciso-math-for-ai-founders
Chapter 4: How I'd Run Security at an AI-Native Company in 2026
SOC 2 covers classic appsec controls. It does not cover the four layers that actually break in AI-native companies: prompt injection, agent credential scoping, secrets handling, and audit logging. This chapter is the technical playbook for the AI-specific work that runs in parallel to your SOC 2 audit, and the 90-day plan for standing it up.
AI-native companies need a security model that classic appsec doesn't cover. Most don't have one.
The pattern I see across early-stage AI companies: a strong engineering team treats security like a 2018 SaaS product: auth, secrets, the SOC 2 checklist. Meanwhile their product is shipping autonomous agents with cloud credentials, accepting unstructured input from customers as the primary interface, and training models on data the customers didn't fully realize they were exposing. The threat model has changed. The controls haven't kept up. The secrets half of that has a concrete Phoenix answer: runtime.exs, Fly, and LLM keys.
If I were building the security program at an AI-native company today, this is the layered stack I'd put in place, the things I'd ship in the first 90 days, and the things I'd consciously defer.
The four-layer stack
Classic appsec is one layer of four. Treating it as the whole picture is the most common mistake I see.
Layer 1: Classic application security
This is everything that's been good practice for fifteen years and doesn't go away because you're an AI company. Auth and authorization. Secrets management. Input validation. SQL injection prevention. CSRF tokens. SSRF guardrails. TLS everywhere. Least-privilege IAM. Logging and audit trails. Backups and recovery.
This layer is solved. The advice has been written down a hundred times. If you're not doing it, do it. If you are, skip the rest of this layer's discussion and move on. The interesting work for AI companies is in the next three layers.
Layer 2: Data security and the training question
The novel question for AI-native companies is what data goes into the model and where it ends up.
The threats:
- Training-data exfiltration. A model trained or fine-tuned on customer data can leak fragments of that data through generation. This is real, has been demonstrated repeatedly, and is not solved by "we delete the data after training."
- Prompt-context leakage. Customer A's data ends up in customer B's response because both customers share the same backend prompt context. RAG pipelines are the worst offender here.
- Vendor-side training. You send customer data to a foundation model API. The vendor uses it to improve their model. Your customer didn't consent to that.
The controls I'd ship:
- Tenant isolation in retrieval. Every vector-DB query and every RAG retrieval must filter by tenant ID at the index level, not in post-processing. This is the single most common AI company security bug I see in code review.
- No-train flags on every vendor API. OpenAI, Anthropic, Google, AWS Bedrock all have versions of "do not use this for training." Default-on, document the setting, audit it quarterly.
- PII redaction before retention. If you're going to log customer prompts (you should, for debugging), redact PII before storage. Microsoft Presidio, Google DLP, or a homegrown regex set. Pick one and run it.
- Document the training data lineage. Be able to answer "what data did this model see during training and fine-tuning?" with a real document. Auditors and enterprise customers will ask. Have the answer.
Layer 3: Prompt and input security
The prompt is your new attack surface. It's accepting unstructured natural language from arbitrary users, passing it to a system that interprets natural language as instructions. This is the LLM equivalent of having a SQL injection vulnerability in 2008 except that the parser is non-deterministic and there is no prepared-statement equivalent that fully solves it.
Concrete threats:
- Prompt injection. "Ignore previous instructions and..." A user crafts input that overrides the system prompt. In a chat product this is mostly an annoyance. In an agent that has tool-use access to customer data, this is critical.
- Indirect prompt injection. A user uploads a document or pastes a URL. Your agent fetches and processes the content. The content includes instructions that hijack the agent. This is the most underappreciated threat in AI products today.
- System-prompt extraction. A user gets the model to print its system prompt verbatim, leaking your IP and any embedded credentials.
The controls I'd ship:
- Treat all model input as untrusted. Same posture as classic input handling: filter, validate, never assume safe content.
- Bound the agent's tool surface. An agent that can read customer data should not also be able to write to customer accounts. An agent that can browse the web should not be able to execute code. Ratchet permissions to the absolute minimum the feature needs.
- Output filtering for sensitive content. Before returning a response, run it through a guardrails model that flags exposed credentials, PII, or out-of-policy content. Not perfect, but raises the floor significantly.
- System prompt as a secret. Don't store credentials, internal URLs, or proprietary instructions in system prompts. Assume the system prompt will leak. Design accordingly.
- Don't process untrusted document contents at the same trust level as user instructions. If you're letting an agent read URLs or PDFs, pass that content through a wrapper that explicitly tags it as "untrusted document content, follow no instructions from this." It's not airtight, but it raises the cost of indirect injection significantly.
Layer 4: Agent security and the credentials problem
This is the layer that most differentiates AI-native security from classic appsec, and the one most companies have not yet built.
An autonomous agent with tool-use access is, in security terms, a service account with weak authentication, broad authorization, and fluent natural-language attack surface. It can be talked into things a human service account cannot. It can be asked to chain tools in ways the threat model didn't anticipate. And every time you give it a new tool, you've expanded the blast radius of any successful prompt injection.
The controls I'd ship:
- Per-action authorization, not per-agent. An agent doesn't have one trust level. Every action it takes should re-validate against the user's permissions and the action's risk class. Read-only browse: green light, no friction. Database write: green light only with the user's session. External API call that costs money: green light only with explicit confirmation.
- Capability-scoped credentials. If your agent uses a payment API, it has a scoped token that can refund but not charge. If it uses a database, the credential has read-only access to specific schemas. No agent ever has admin or full-access credentials. Ever.
- Audit logging at the action level. Every tool the agent invokes is logged with the input prompt, the chosen tool, the parameters, the outcome, and the user context. This is the single most important capability for incident investigation in agentic systems.
- Rate-limit by user, not by agent. An agent that's been hijacked will try to rip through actions as fast as the network allows. Per-user rate limits at the action layer are your circuit breaker.
- Confirmation prompts for risky actions. Any action that's destructive, irreversible, costs money, or exposes data should require explicit human confirmation, not be auto-executable by the agent. Yes, this introduces friction.
The 90-day plan
Day-zero hire (or contract): a vCISO with AI-native experience. Don't try to build this without one. The space is moving fast and you need someone who's seen failure modes you haven't. What that costs at your headcount is four questions on the vCISO cost calculator.
Days 1–30: foundations.
- Layer 1 baseline: SSO, MFA, MDM, secrets vault, IAM least-privilege review.
- Layer 2 controls: no-train flags everywhere, RAG tenant isolation audit.
- Set up audit logging at the action level for any agent or tool-using LLM.
- Document model lineage for every model you ship.
Days 30–60: prompt and agent.
- Adversarial review of every system prompt. Assume it will be extracted; remove anything that should not be public.
- Tool-permission audit: every agent's available tools, mapped to risk class, with confirmation gates added where missing.
- Indirect-prompt-injection testing on document and URL ingestion paths.
- PII redaction in logs and analytics pipelines.
Days 60–90: program.
- SOC 2 Type I readiness, scoped to include AI-specific controls (data lineage, no-train, agent action logging). Most off-the-shelf SOC 2 templates do not include these.
- Customer-facing security documentation: trust page, AI usage disclosure, data handling policy. Enterprise prospects will ask.
- Incident response runbook with AI-specific scenarios: prompt injection at scale, data exfil via training, agent runaway.
- Quarterly security review cadence with founders and key engineering leads.
The AI Startup Security Bundle covers two pieces of that: one kit has your agent interview you and write the answer bank for buyer security questionnaires, the other writes managed policy files and evidence capture for Claude Code and Codex.
What I'd defer
The instinct in security programs is to over-include. At the speed an AI startup moves, that's fatal. Every control has a maintenance cost, and a security program that pisses off engineering will be worked around inside a quarter.
Things I'd consciously defer at the early stage:
- Heavy DLP tooling. Worth it at scale, distracting at fifteen people.
- Endpoint detection and response. MDM gets you most of the value at this stage. Real EDR comes after Series B.
- SIEM platforms. Centralized logging is great. A full SIEM with detection rules is overkill before you have a security team to run it.
- Bug bounty programs. Run them once you have a triage process. Before that, they generate noise.
- Penetration tests beyond what your customers require. One annual pentest scoped to your customer requirements is enough until you're in a regulated vertical.
The discipline is doing the controls that matter at your stage and not the ones that look impressive on a security marketing page. Which ones those are for a sub-20-engineer team, and the person/artifact/failure-mode test for whether a control is real at all, is its own argument.
The takeaway
AI-native security is not classic appsec plus "be careful with prompts." It's a four-layer stack, and three of those layers (data, prompt, agent) are mostly novel relative to where most engineering teams have built up muscle memory.
You will get most of the value from tenant isolation in retrieval, scoped credentials for agents, action-level audit logging, and confirmation gates on destructive actions. Those four controls handle the vast majority of the AI-specific failure modes I've seen at production scale.
Everything else is sequencing and discipline. Don't skip Layer 1. Don't pretend Layers 2–4 don't exist. Hire a vCISO who's seen this space before. Document what you do and don't do, because your customers, your auditors, and your future self will all want to know.
The companies that get this right in the next two years will look like reasonable enterprise vendors. The ones that don't will spend a quarter on incident response that should have been spent on product.
Canonical web version: sublimecoding.com/blog/running-security-at-an-ai-native-company-2026
Chapter 5: Secrets Management for AI Agents on Small Teams
The previous chapter names agent credentials and secrets as two of the four layers. This one is the working version for a team of five: keep credentials with the tools instead of the model, scope them per tool, keep them short-lived where that's cheap, and rehearse the kill switch before you need it.
TL;DR: The model never needs the key. That one sentence is most of agent secrets management, and almost every setup I see gets it backwards. The API key sits in the agent’s environment or, worse, in its context window, where a single prompt injection turns your assistant into an exfiltration tool. At small-team scale the fix is an architectural habit, with no identity platform needed: credentials live with the tools, tools execute with the narrowest credential that does the job, the model only ever sees results. Add short-lived tokens where your providers make it easy, log what the agent touched, and keep one kill switch you’ve actually tested. The identity-for-agents vendor pitch can wait until you have agents enough to need it.
The model never needed the key
Walk through what actually happens when your agent “uses” a
credential. The model emits a tool call (a blob of JSON saying
query_database with some arguments). Your code receives that
JSON, executes the query, and returns rows. At no point in that loop
does the model need the database password. The code that runs
the tool needs it. The model needs the result.
This is obvious once you say it out loud, and yet the default wiring
of most agent stacks ignores it. The agent process gets the same
.env the app gets. Every tool call executes with the full
ambient authority of everything in that file: the Postgres superuser,
the Stripe live key, the AWS credentials with * on the
resource ARN. Nobody decided the agent should have all that;
the agent inherited the human-shaped
credential model, and the human-shaped credential model assumes the
thing holding the keys has judgment. Loading that file into a shell is its own risk: sourcing a cloned repo's
.env runs it as code.
An agent has no judgment. It has instructions, and it takes new instructions from anything that lands in its context: a support ticket, a scraped web page, a README in a cloned repo. Prompt injection is precisely the trick of making retrieved content count as instructions, and a credential the model can see is a credential the model can be talked into repeating. The mid-2025 Supabase incident was the canonical version: an agent with privileged service-role access processed support tickets containing attacker-supplied instructions, and integration tokens ended up in a public thread. Excessive privilege plus untrusted input is the recipe, and it’s the top entry in OWASP’s MCP Top 10 for a reason.
The scale of the sprawl backs this up. GitGuardian counted 28.6 million new secrets exposed in public GitHub commits in 2025, a 34% jump, the biggest in the report’s history, including over 24,000 unique secrets sitting in MCP configuration files specifically. Agents didn’t invent secrets sprawl. They industrialized it, because an agent commits, configures, and copies at machine speed, and it never gets the uneasy feeling a human gets pasting a key somewhere it doesn’t belong.
Three ways agents break the human credential model
It’s worth being precise about what’s actually new here, because “treat the agent like an employee” (the framing half the vendor content uses) leads you to the wrong controls.
Speed. A human with an over-scoped key misuses it occasionally, detectably, at human pace. An agent makes hundreds of tool calls an hour. If one of them is wrong (wrong table, wrong environment, wrong recipient) the blast radius is bounded only by what the credential allows and how fast you notice. I wrote about Amazon learning this in public: the mistake was ordinary and the amplification was new.
Injectability. You cannot socially engineer your deploy script. You can socially engineer your agent, remotely, in writing, at scale, by putting words where it will read them. Every credential in the model’s reach is one crafted document away from disclosure. This is why the autonomy question and the credential question are the same question wearing different hats.
Ambient authority. Humans accumulate scoped logins with MFA and session expiry. Agents accumulate environment variables, long-lived, unscoped, invisible. OWASP’s agentic guidance pushes “least agency” alongside least privilege: don’t just ask what the agent can access, ask how much it can do with that access before a human checks. An env file full of god-keys maximizes both.
The broker pattern: credentials live with tools
The architectural fix is small enough to describe in one paragraph.
Between the model and every side effect sits a broker, the code that
receives the tool call, decides whether to run it, executes it with a
credential the model has never seen, and returns only the result. If
you’ve read the
50-line agent loop, you’ve already seen the shape: the loop’s
execute_tool/2 function is the broker seam. You
just have to treat it as a security boundary instead of a dispatch
table.
In Elixir it barely deserves the word “pattern”:
defmodule Agent.Broker do
# Each tool gets its own credential, fetched at call time —
# never placed in the prompt, never returned to the model.
@tools %{
"search_orders" => {Tools.Orders, :readonly_db_url},
"refund_order" => {Tools.Refunds, :stripe_restricted_key},
"send_email" => {Tools.Email, :smtp_send_only}
}
def call(tool_name, args, ctx) do
with {:ok, {mod, cred_key}} <- Map.fetch(@tools, tool_name),
:ok <- Policy.allow?(tool_name, args, ctx) do
cred = Secrets.fetch!(cred_key)
result = mod.run(args, cred)
AuditLog.record(ctx.run_id, tool_name, args, summarize(result))
{:ok, redact(result)}
end
end
endThree properties matter more than the code. The credential is fetched inside the call, so it exists in memory for the duration of one tool execution, not for the lifetime of the agent process. The result is redacted before it returns: if the tool response could contain secrets (config dumps, user records with tokens), strip them, because whatever goes back to the model becomes context, and context can be exfiltrated by the next injection. And every call is logged with the run ID, because when something goes wrong the first question is “what did the agent touch,” and grepping model transcripts is a miserable way to answer it.
If your agent reaches tools through MCP servers instead of in-process
functions, the boundary moves but the rule doesn’t: the MCP server holds
the credential, scoped to what that server does, and the config that
launches it is a secrets-bearing file, which is exactly where
GitGuardian found those 24,000 leaked keys. Treat mcp.json
with the paranoia you’d give .env, because it is one.
Scope per tool, not per agent
The unit of least privilege is the tool. “The support agent’s key” is already too coarse: the support agent’s order-lookup tool needs a read-only database role limited to two tables; its refund tool needs a Stripe restricted key capped at refunds; its email tool needs send-only SMTP with your domain locked. Each of those is a five-minute setup task in the respective dashboard, and each converts a catastrophic injection outcome into an annoying one. An attacker who fully owns the model in that architecture can issue refunds until your cap trips. They cannot read your user table, mint API keys, or touch the infrastructure, because no tool in reach holds a credential that can.
This is the same argument I make in the AI-native security stack post at the company level, and this is what it compiles down to at the code level. Providers have made it easy: Stripe restricted keys, Postgres roles, GitHub fine-grained PATs, AWS IAM with resource conditions. The primitives are all old. What’s new is having a caller that will predictably, mechanically use everything a credential allows, which turns scoping from best practice into a requirement.
Short-lived beats static, where it’s cheap
Static keys leak and stay leaked; the GitHub incident-response literature is a graveyard of keys revoked months after exposure. Every credential your broker fetches should be as short-lived as your provider makes convenient: AWS STS sessions instead of IAM user keys, OIDC-federated tokens in CI, database credentials from Vault-style dynamic issuance if you already run it, and if you don’t, a weekly rotation habit on the handful of static keys you can’t avoid.
The honest small-team version: you will not get everything short-lived, and you don’t need to. Rank by blast radius. Cloud-account credentials and anything that can move money go first. The key to your error tracker can stay static without keeping anyone up at night. OWASP’s framing, task-scoped, time-bound permissions, is the ideal; a five-person team gets most of the value from applying it to the three credentials that matter and consciously deferring the rest.
The five-person reality check
Since “it depends on your stage” is doing a lot of work above, here’s the explicit line I’d draw for a team of five with agents in the development loop and maybe one in production:
Fine: secrets in environment variables on the tool-executing process, loaded from a managed store (Fly secrets, AWS SSM, 1Password CLI, whichever you already have). Per-tool scoped keys. A shared runbook that says which keys exist and who rotates them. Agents in dev running with dev credentials against dev data.
Negligent: any credential in a prompt, system message, or file the agent is instructed to read. One key shared across tools “for now.” Production credentials in the environment of a coding agent that executes arbitrary shell commands. Remember that cloning a repo was enough to redirect an API key in CVE-2026-21852; your agent’s environment is attack surface even when the agent behaves. No log of agent tool calls. No tested way to shut it off.
That last pair costs an afternoon, total.
Kill switch, then rotation
When an agent misbehaves (and the base rate says eventually one will) you need two moves you’ve rehearsed. First, stop the agent: a feature flag the broker checks on every call beats hunting for the process at 2am. Second, rotate what it held, which is only tractable if you scoped per tool, because “rotate everything in the env file” is exactly the Saturday you built all this to avoid. This is also where the audit log pays for itself: rotation scope equals the set of credentials behind tools the run actually called, and the log is the only thing that knows. Buyers ask about agent credentials and the agent kill switch in their security questionnaires, and The AI Startup Security Questionnaire Kit has your agent interview you about the program you run and writes the answers down.
Keys you hand to third parties
The same rule applies when the tool isn’t yours. Some revenue dashboards and analytics tools ask you to paste a Stripe key so they can read your numbers. Stripe’s docs say a restricted key is the safer thing to hand over: each resource is set to None, Read or Write, and a key that can write a resource can also read it.
Read-only still covers a lot. Read access to Customers returns each
customer’s email, name,
phone, billing address and
shipping address, per the Customer object
reference. A vendor that only needs your revenue figures needs none
of that. Before you paste a key:
- Create one restricted key per vendor, start from no permissions, and grant Read only on what the vendor says it uses.
- Leave Customers at None unless the product can’t work without it, and ask the vendor why if it can’t.
- Name the key after the vendor, so revoking it later takes one click.
- After the first week, open that key’s request logs in the Dashboard. They show what the vendor actually calls.
- If the vendor calls from stable IP addresses, ask for them. Stripe lets you limit a key to those addresses.
When you stop using the vendor, delete its key the same day.
What not to buy yet
There is a fast-growing category of agent-identity platforms: non-human identity management, agent IAM, credential brokers as a service. The pitch is real for enterprises running fleets of agents across hundreds of systems with compliance reporting on top. At pre-Series-A, with one product and a handful of tools, the platform mostly sells you a hosted version of the broker function above, plus a new vendor in your critical path and a new place your credentials live.
Buy it when you have the problem it solves: many agents, many teams, auditors asking for agent-access reviews, or a credential graph you genuinely can’t hold in your head. Until then the boring stack (scoped keys, a broker seam you own, your platform’s secret store, one log) covers a five-person team with money left over. This is the same prove-the-return discipline that applies to every tool purchase; security tooling doesn’t get an exemption.
The part that doesn’t change
Strip the AI vocabulary and this post says: don’t give programs more authority than their job needs, don’t put secrets where untrusted input can reach them, log privileged actions, and be able to revoke fast. That was true before LLMs. What agents change is the default: for the first time, the path of least resistance hands a credulous, injectable, machine-speed actor the keys to everything, and the ecosystem’s leak statistics show how that’s going. (One Linux distribution now ships that default as a keybinding: I inventoried what it hands an agent.)
If you’re standing up agents with real credentials and want a second pair of eyes on the boundary (what’s scoped, what’s brokered, what you can safely defer), that’s the kind of engagement I run.
Canonical web version: sublimecoding.com/blog/ai-agent-secrets-management
Chapter 6: Building an LLM Audit Trail That Passes SOC 2
The fourth layer is audit logging, and it's the one your SOC 2 auditor will ask about by name. This chapter covers what SOC 2 asks you to log about each model call, why the provider request ID is the field that saves you, the retention tension, and what an auditor asks for when they sample entries. The example is an append-only Ecto schema; the shape carries to any stack.
TL;DR: Every SOC 2 guide that mentions LLMs stops at policy language (“log access to AI systems”) and never shows you the table. Here’s the table. An append-only
llm_audit_eventsschema in Ecto, the exact fields that make an entry defensible in an auditor’s sample versus decorative, and the field most teams skip that ends up saving them in the room: the provider’s own request ID. Also covered honestly: whether you have to log the raw prompt (usually yes, with a redaction step, not a blanket no), and how long to keep any of it before “audit trail” becomes “unmanaged PII warehouse.”
The instrumentation point is the same call, different consumer
Metering LLM usage per
customer in Phoenix covers the append-only ledger you build to bill
a tenant for token usage: integer micro-dollars, idempotent writes keyed on a provider request ID, never :float. This post
instruments the same outbound call, but the record it produces
answers a different question and lives under different rules. A billing
ledger exists to defend an invoice line for as long as you keep
customers; it can be thin: tenant, tokens, cost, done. An audit trail
exists to defend a claim about control, to a third party you
didn’t choose, on a schedule you don’t control, and it has to survive
scrutiny of who called what, with what input, under whose authority, for
as long as your retention policy says it does. It uses the same :telemetry hook as the ledger but needs a different table, different columns, and a different retention clock.
There’s a third consumer of that same call worth separating out. The agent evidence pack for a security review specifies the tool-call record as a reviewer-facing artifact: the field set you hand someone evaluating your product, and how to generate it so it can’t drift from the code. This post is the storage side of that record: the schema it lives in, the retention clocks it runs on, and what an auditor pulls out of it. Read that one for what to show; read this one for what to build.
If you haven’t wired the underlying telemetry yet, the ReqLLM integration
walkthrough covers the event shapes this post assumes, specifically [:req_llm, :request, :stop], whose metadata already carries
request_id, provider, model, and
finish_reason before you’ve written a line of your own
code.
What SOC 2 actually asks you to log
The reframe I give founders heading into their first SOC 2 is that there is no “AI” criterion to satisfy. There are criteria that predate LLMs by a decade and apply to them without modification, and knowing which ones is what separates a defensible answer from a guess in the audit room. SOC 2 as a revenue tool rather than a security project is why you’re in the room at all; this is the artifact that has to survive once you’re there.
CC7.2 (System Operations) requires the entity to monitor system components for anomalies and analyze them to determine whether they’re security events. This is the criterion an LLM call log most directly satisfies, because a prompt-injection attempt or a call from a deprovisioned service account is the anomaly it’s asking you to be able to detect. The criterion’s own words are “monitors system components and the operation of those components for anomalies that are indicative of malicious acts, natural disasters, and errors” (AICPA, TSP Section 100, 2017 Trust Services Criteria). CC6.1 and CC6.3 (Logical and Physical Access Controls) govern who’s authorized to trigger the call in the first place, which is why “calling user or tenant” is a required column, not an optional one: an audit log with no actor attached can’t prove access was restricted to authorized parties. CC7.3 (System Operations) picks up where CC7.2 stops: it covers evaluating the security events CC7.2 surfaced to determine whether they rise to security incidents (a failure to meet your objectives) and taking action if they do. That evaluation only works if the log entry carries enough context (input, output, timestamp, actor) to judge against.
None of that is AI-specific. What’s new is the volume and the surface area: a REST API you called twelve times a day now gets called on every user keystroke, through an SDK whose retry behavior you don’t fully control, against a vendor whose model version changes under you. The criteria didn’t change. The number of events that need to satisfy them did. Controlling what you send in the first place is the other half of that: throttling against the provider’s real TPM and RPM ceilings keeps the 429 from happening at all.
An append-only Ecto schema for LLM audit events
Same discipline as the billing ledger (no update, ever, corrections are new rows) but a wider column set, because the auditor samples for a story: who did what, to which model, with what result.
create table(:llm_audit_events,
primary_key: false) do
add :id, :binary_id, primary_key: true
add :occurred_at, :utc_datetime_usec,
null: false
add :actor_id, :binary_id, null: false
add :actor_type, :string, null: false
add :tenant_id, :binary_id, null: false
add :provider, :string, null: false
add :model, :string, null: false
add :provider_request_id, :string,
null: false
add :input_tokens, :integer, null: false
add :output_tokens, :integer, null: false
add :latency_ms, :integer, null: false
add :tool_calls, {:array, :map},
default: []
add :finish_reason, :string
add :prompt_digest, :string, null: false
add :prompt_redacted, :text
add :outcome, :string, null: false
timestamps(updated_at: false)
end
create unique_index(
:llm_audit_events,
[:provider, :provider_request_id],
name: :llm_audit_events_provider_request_idx
)
create index(
:llm_audit_events,
[:tenant_id, :occurred_at]
)
create index(
:llm_audit_events, [:actor_id]
)prompt_digest (a SHA-256 of the raw prompt) always gets
written, even when prompt_redacted doesn’t. It lets you prove which prompt produced a given output, and lets you
re-associate a customer complaint with an exact call, without keeping
the raw text around by default. More on that split below.
The Ecto schema, with the invariant a future reader needs written where they’ll see it:
defmodule MyApp.Audit.LLMEvent do
use Ecto.Schema
import Ecto.Changeset
@primary_key {:id, :binary_id,
autogenerate: true}
schema "llm_audit_events" do
field :occurred_at, :utc_datetime_usec
field :actor_id, Ecto.UUID
field :actor_type, :string
field :tenant_id, Ecto.UUID
field :provider, :string
field :model, :string
field :provider_request_id, :string
field :input_tokens, :integer
field :output_tokens, :integer
field :latency_ms, :integer
field :tool_calls, {:array, :map},
default: []
field :finish_reason, :string
field :prompt_digest, :string
field :prompt_redacted, :string
field :outcome, :string
timestamps(updated_at: false)
end
# append-only: no update_changeset/2 exists
# on this module. Corrections are new rows
# with :outcome set to "superseded".
@fields ~w(occurred_at actor_id actor_type
tenant_id provider model
provider_request_id input_tokens
output_tokens latency_ms
tool_calls finish_reason
prompt_digest prompt_redacted
outcome)a
def changeset(event, attrs) do
event
|> cast(attrs, @fields)
|> validate_required(@fields -- [
:prompt_redacted, :finish_reason
])
|> unique_constraint(
:provider_request_id,
name: :llm_audit_events_provider_request_idx
)
end
endWriting this from inside the same call wrapper the billing ledger
uses is deliberate: one project-owned
MyApp.LLM.call/3 that requires actor_id and
tenant_id as arguments, emits one billing row and one audit
row from the same :telemetry handler, off the same event.
Two consumers, one instrumentation point, no code path that reaches the
provider without both attached.
Why the provider request ID is the field that saves you
The provider request ID is the join key that lets you prove your log
matches the vendor’s log, which is the difference between an entry an
auditor believes and one they don’t. Every major provider stamps a
request ID on its response: x-request-id from OpenAI,
request-id from Anthropic, x-amzn-requestid
from Bedrock. ReqLLM already surfaces it in the
[:req_llm, :request, :stop] metadata as
request_id, so capturing it costs you nothing beyond a
column. One gotcha carried over from that post: model
arrives as an LLMDB.Model struct rather than a string, so
take .id before it reaches the changeset.
Here’s the failure mode it prevents. An auditor doing Type 2 testing
doesn’t take your word for a control’s operating effectiveness across the review period. They pull a sample of events and check each one has
proof. If their sample includes an LLM call and your row has no way to
independently verify it happened as described, you’re asking them to
trust your application’s own account of itself, which is close to the
definition of an unauditable control. A provider_request_id
gives a reviewer something to check that you didn’t author. How strong
that check is depends on the provider. On Bedrock it’s the best case: model
invocation logging writes each call’s requestId,
calling principal ARN, and input/output token counts to CloudWatch Logs
or S3, though it is disabled by default, so turn it on before you need
it rather than after. With OpenAI and Anthropic the path is narrower:
the ID is what their support resolves a disputed call against, and your
token counts still reconcile against the usage they invoice you for.
With either, the row stops being a bare claim.
A row with a provider request ID is a claim with a witness. A row without one is just your application’s word for what happened.
It’s also the field that makes incident response tractable under CC7.2/CC7.3: “this model call misbehaved” becomes “here’s the exact provider-side request, escalate it to their support with this ID” instead of “here’s an application log we hope corresponds to something.”
Do you have to log the prompt?
Usually yes, but not the raw text by default. You need enough to
reconstruct what happened without warehousing customer PII you have no
retention plan for. The prompt_digest /
prompt_redacted split is the practical answer: hash every
prompt unconditionally (cheap, reversible only with the original text,
and enough to prove which input produced which output), and only store
redacted or truncated prompt text when your data-handling policy
explicitly allows it for that tenant and that data class.
Redaction in practice means running a PII scrubber (structured field
masking for known formats such as emails, SSNs, and card numbers, plus a
conservative regex pass) on the prompt before it’s written to
prompt_redacted, and treating anything you can’t
confidently classify as “don’t store it, keep the digest.” This is a
judgment call your data classification policy should make explicit, not
one an engineer should default on ad hoc per feature, which is the same governance gap running
security at an AI-native company argues costs teams the most when
it’s left implicit.
The trap to avoid is the binary version of this decision: “we log everything” turns your audit trail into the biggest unencrypted PII surface in the company, and “we log nothing” turns it into an audit trail an auditor can’t actually use. The digest-plus-conditional-redaction split is what lets both things be true: you can prove exactly which prompt produced a disputed output when you’re authorized to look, and you’re not carrying raw customer text you never needed for anything but that one dispute. Buyers ask about this in security questionnaires too, including whether prompts are retained and whether tool calls are logged, and The AI Startup Security Questionnaire Kit has your agent interview you and writes the answers down.
Retention: the tension nobody writes down
Retain audit records only as long as your documented policy says, and
no policy should say “forever”, and SOC 2 doesn’t mandate a duration. If
your report includes the Confidentiality or Privacy categories, C1.1 and
P4.2 put you on the hook to define a retention period and dispose on it,
and an auditor will check your documented period against what’s actually
in the table. If you scoped Security only, which most startups do, nothing forces the question, which is exactly why teams never answer it
and end up with a five-year-old prompt table nobody owns. A common,
defensible split: prompt_digest, token counts, actor, and
provider_request_id (the audit-value columns) live for the
length of your audit window plus a buffer (13 months covers a Type 2 period with room to spare) while prompt_redacted gets a
shorter clock, often 30–90 days, because raw text is the
highest-liability column in the table and the one with the least ongoing
audit value once the immediate incident-response window has closed.
Build the shorter clock as an actual job, not a policy document nobody automates:
defmodule MyApp.Audit.PurgeRedactedPrompts do
use Oban.Worker, queue: :maintenance
import Ecto.Query
@retention_days 60
@impl Oban.Worker
def perform(_job) do
cutoff = DateTime.utc_now()
|> DateTime.add(-@retention_days, :day)
from(e in MyApp.Audit.LLMEvent,
where: e.occurred_at < ^cutoff,
where: not is_nil(e.prompt_redacted)
)
|> MyApp.Repo.update_all(
set: [prompt_redacted: nil]
)
:ok
end
endNotice this nulls prompt_redacted and leaves everything else in the row: the digest, the actor, the request ID, and the token counts all survive, because those are the columns that carry audit value
across the full retention window. The row stays and only the raw text goes.
This is the one sanctioned mutation of an otherwise append-only
table, and it’s worth writing down as an invariant rather than
rediscovering it during an audit: the purge job may null
prompt_redacted and nothing else. No column an auditor
samples is ever rewritten. If you want the database holding that line
instead of code review, a column-level grant or a Postgres rule will do
it.
What does an auditor actually ask for?
A sample of events across the review period, and for each one: proof the actor was authorized, proof the call happened as logged, and proof an anomaly (if any occurred) was evaluated per your documented process. What makes a sampled row pass or fail comes down to whether each field is independently checkable or just asserted.
| Field | Why it’s captured | What it proves to an auditor |
|---|---|---|
actor_id / actor_type |
Ties every call to an authorized identity, satisfying CC6.1/CC6.3 | Access was restricted to authorized parties, not anonymous or shared credentials |
provider_request_id |
Vendor-issued, independently verifiable | The call happened as described, not just your application’s word |
occurred_at (usec precision) |
Correlates with vendor logs, rate-limit windows, and incident timelines | The sequence of events is reconstructable, not approximate |
tenant_id |
Scopes the call to a customer/data boundary | No cross-tenant data exposure in a multi-tenant system |
prompt_digest |
Hash of the exact input, always written | Which input produced which output, without storing raw text by default |
finish_reason / outcome |
Flags truncation, refusal, or error states | Anomalies were captured, not silently dropped (CC7.2) |
input_tokens / output_tokens |
Sizes the interaction | Corroborates cost and volume against provider billing, an independent cross-check |
A row missing provider_request_id or
actor_id is unfalsifiable, and an auditor’s job is to reject unfalsifiable evidence.
What makes an entry defensible instead of decorative
The short version: every field a stranger could independently check,
versus every field that only your own application vouches for. A log
statement that says "LLM call succeeded" in your Sentry breadcrumbs is decorative, because it’s true only when your code says it’s true. A row with a provider request ID, an authenticated actor, a token
count that reconciles against the vendor’s own invoice, and a timestamp
precise enough to sequence against a rate-limit event is defensible,
because three of those four fields can be checked against a source you
don’t control.
This is the same distinction security controls that assume a team you don’t have makes about controls generally: a policy document is decorative until something makes it operational, and an audit trail is the specific place that gap shows up first, because it’s the artifact the auditor actually opens. If you’re heading into a SOC 2 process for the first time and want a second set of eyes on which controls in your stack do real work versus theater before the auditor tells you, that’s exactly the kind of gap review I do as a fractional CTO / vCISO for AI startups, and it’s cheaper to find in a working session than in a finding.
Read this next
If SOC 2 readiness for an AI product is new territory generally, surviving enterprise security reviews as an AI startup covers the broader review a prospect’s security team runs before signing, of which an audit trail like this one is a single piece.
Canonical web version: sublimecoding.com/blog/llm-audit-trail-soc2
Chapter 7: What 90 Days of a Fractional Security Engagement Actually Looks Like
The previous chapters describe the strategic decisions. This chapter compresses them into operational reality: a sanitized week-by-week composite of a typical 90-day fractional CISO engagement at a Series-Seed AI startup with two enterprise prospects in pipeline. What gets done, what it costs, what graduates the founder out of needing one. If you've read the rest of the playbook and are at "okay, what would the next 90 days actually look like," this chapter is the answer.
Most founders who book the intro call have already read three or four of my posts and arrive at the same question: "Okay, but what would the next 90 days actually look like if I hired you?" Here's the answer: a sanitized week-by-week composite of a typical 90-day fractional security engagement, with the real numbers attached.
Not every engagement looks exactly like this. But this is what most pre-Series-A AI engagements look like: same shape, different details. Composited from real work, no specific client.
The starting state: a Series-Seed AI startup, eight engineers, ARR in the low seven figures, two enterprise prospects in pipeline. Both prospects are stuck at the security questionnaire. One explicitly asked for SOC 2 Type I; the other implied it. The founders haven't run a security program before. The CTO has been triaging the questionnaires personally and hates every minute of it.
The ask: get them through both questionnaires within 90 days, run the SOC 2 Type I audit in parallel, and stand up the security work that needs to outlast the engagement.
Week 0: the scoping call
Thirty minutes, and it is mostly me asking questions. What are your current goals. Where does your compliance actually stand. What are you using to monitor it, and what do you wish it did better. What do you need the most help with. Are you losing sales over a compliance structure you don't have yet, and have clients started asking for it by name. Where those land decides what I drill into next, usually infrastructure, sometimes something else entirely.
No single answer decides anything. The shape of the engagement comes out of the whole conversation, and sometimes that shape is smaller than what the founder walked in asking for. Two things do need to be in place before we start, though neither is what decides whether we work together: a budget, and someone internal I can talk to, usually the CTO or a senior engineer who will absorb the role after I'm gone. Without an internal owner there is nobody for the work to outlast me in.
Pricing gets confirmed on this call too. Current rates are on the consulting page, and you can run your own numbers in the vCISO cost calculator. Audit-prep engagements run four months, occasionally six. Deliverables and out-of-scope items go into a one-page scope doc the next day. No surprise overages. No retainer creep. What a four-month embedded engagement actually ships, month by month, is written up separately.
Weeks 1–2: discovery and the policy pack
Discovery is short by design. I run a one-week assessment instead of a six-week one, because I already know what most pre-Series-A AI startups look like and what they're missing. The week is for confirming the gaps, not for finding them.
What gets done in week one: read all the existing security documentation (usually a one-page README and a handful of Notion pages), interview the CTO and the founder for an hour each, walk the production environment with whoever's on-call, and pull the existing controls into a SOC 2 readiness matrix. By the end of week one, the gap list is on paper.
Week two is the policy pack. Acceptable use, access control, data classification, incident response, vendor management, change management, vulnerability management, business continuity. Eight policies, drafted in the company's voice from templates I've been carrying for years, customized to the actual technology stack. The CTO reviews and signs off. We push them into the Vanta or Drata instance the same week.
By end of week two, the company has policy language that holds up to an auditor's read and a written gap list ranked by audit-blocking severity.
Weeks 3–6: SOC 2 readiness in parallel with the AI security stack
This is the heavy stretch. Two work streams running in parallel.
The SOC 2 stream: implement controls against the gap list, configure the compliance tool to track evidence collection, schedule the auditor (early, since the good ones book out four to six weeks), document the technical controls (MFA enforcement, access provisioning, secure SDLC), and start collecting evidence as the controls go live. Most of the engineering team's involvement happens in week three when we configure the access provisioning tooling and again in week five when we wire the production change management process into their existing PR workflow.
The AI security stream: this is where the work that's not in the SOC 2 framework lives. The four-layer AI-native stack (prompt injection defense, agent credential scoping, secrets handling, audit logging) gets stood up in this window. Credential scoping comes first, because that's where the largest blast-radius incidents originate. By end of week four, every agent and every service account has the minimum credential surface needed to do its job. No "admin to be safe" anywhere.
By end of week six, both streams have visible momentum. Vanta or Drata shows green on most of the framework. The AI-native layer has credential scoping done and prompt injection guardrails in design. Both enterprise prospects get an updated security questionnaire response that shows real evidence of the work, and both move forward on their evaluation.
Weeks 7–10: auditor engagement and the AI-native layers
Weeks seven and eight are auditor fieldwork. The auditor runs interviews with the team, walks the production controls, samples the evidence, and asks the questions that don't have clean answers. My job in this stretch is to be the security executive in the room with the auditor, answering the technical questions, defending the design decisions, and protecting the engineering team from the death-by-questionnaire pattern that kills first-time SOC 2 attempts.
Weeks nine and ten close out the AI-native layers. Secrets handling moves from ad-hoc (env vars and the occasional .env checked into a private branch) to deliberate (Vault or AWS Secrets Manager, automated rotation on the secrets that actually matter). Audit logging gets stood up: every agent action, every privileged service account call, every credential-bearing API request goes to a central log with retention long enough to investigate an incident a month after it happens.
By end of week ten, the auditor's draft report is in review. Both enterprise prospects have what they need. The technical work outlives the engagement.
Weeks 11–12: report and graduation
Week eleven is the auditor report cycle. Their draft, our review, their final. The Type I report ships at end of week eleven or early week twelve. Both enterprise prospects close their security review within ten business days of the report landing.
Week twelve is the graduation conversation. I always have the same conversation around this point. "You don't need me on the day-to-day anymore. Here's what comes next, and here's when you'd hire someone full-time."
Most engagements either step down to a low-touch advisory retainer (four to six hours per month, mostly for security review questions and the next year's audit prep) or graduate completely. The bad outcome is the one where I'm still the on-call security executive at month nine. That means I haven't built the program right. The internal owner identified in week zero needs to be operational by week twelve, or I've failed the engagement.
What you have at the end of each phase
If you’re comparing vCISO (virtual CISO) offers, this is the list to hold them to. Everything in it is from the weeks above.
| Weeks | Phase | What exists at the end |
|---|---|---|
| 0 | Scoping | A budget and a named internal owner, usually the CTO or a senior engineer |
| 1–2 | Discovery and policy pack | The gap list in a SOC 2 readiness matrix; eight policies: acceptable use, access control, data classification, incident response, vendor management, change management, vulnerability management, business continuity |
| 3–6 | SOC 2 readiness and AI security | Controls implemented against the gap list, evidence tracked in Vanta or Drata, the auditor booked, change management wired into the PR workflow, and every agent and service account scoped to minimum credentials |
| 7–10 | Auditor fieldwork and AI-native layers | Fieldwork done, secrets in Vault or AWS Secrets Manager with rotation, and audit logging for agent actions and privileged calls |
| 11–12 | Report and graduation | The SOC 2 Type I report, and a step-down or graduation plan with the internal owner operational |
What it cost
Total 90-day spend, all in:
- Auditor fee: $15–20K (varies by auditor, scope, and audit-prep tooling)
- SOC 2 tooling (Vanta or Drata, year one): $5–10K
- Fractional CISO retainer: four months, at the rates on the consulting page
- Internal time: roughly four hours per week of the CTO's attention; less for the engineering team after week three
Total external spend: $20–30K for the auditor and tooling, plus four months of the retainer. With the retainer, that lands inside the $25–45K range I quote in the SOC 2 post, on the higher end because of the AI-native layers added in parallel.
Cost of NOT running this engagement: two enterprise deals that don't close. Pipeline that ages out. The CTO answering security questionnaires personally for the next six months instead of building the product.
What actually changed
Two named enterprise deals unblocked. SOC 2 Type I report in hand for the next six prospects. A security program that outlives the engagement: one internal owner, one accountable executive, weekly review cadence, and a roadmap to Type II audit at the next renewal.
Specific operational outcomes: every service account has minimum-viable credentials. Every agent has bounded tool access. Every secret is in a manager with rotation policy. Every privileged action lands in a searchable audit log. None of these existed at week zero.
Cultural outcomes that matter just as much: the CTO knows what to say in a security questionnaire and what to escalate. The engineering team has a security review pattern they can run for new features without me. The founder has a real number for what compliance costs at the next stage.
When this engagement isn't right
Not every founder should hire a fractional CISO. The wrong fit produces a worse outcome than no fit at all.
Wrong-fit signals:
- The deal blocking on the security review isn't real. ("We think SOC 2 would help us close more enterprise" without a specific named prospect = wrong stage.)
- No internal owner. If nobody on the team will absorb the role at month four, the engagement either extends indefinitely or rolls back inside two quarters.
- Regulated industry that requires a full-time CISO on the org chart for the deals being pursued. Healthcare with PHI, payments, government.
- Security work consistently exceeds 20 hours per week. Past the fractional break-even, full-time is now the right answer. (See the vCISO math post for the graduation criteria.)
If any of those describe you, the conversation we should have isn't about hiring me. It's about what your real next move actually is. I'll say so on the call.
How to get this conversation started
If you're a pre-Series-A AI founder with a named enterprise deal blocked behind security review, the intro call is the right step. Thirty minutes. Three questions. We figure out together whether this engagement shape is the right one for you, and if it isn't, I'll point you at what is.
Engagement model and the next step are here.
Read this next
- vCISO Math for AI Founders: the make-vs-buy argument and the graduation criteria.
- SOC 2 Is a Revenue Tool, Not a Security Tool: the reframing that makes the engagement above worth running.
- How I'd Run Security at an AI-Native Company in 2026: the four-layer stack the engagement above stands up.
Canonical web version: sublimecoding.com/blog/what-a-fractional-security-engagement-actually-looks-like
Chapter 8: Security Engineer or vCISO? Your First Hire, by Stage
The engagement chapter ends at graduation. This one is the decision that comes after: when the next security person should be a full-time engineer, when fractional leadership still fits, stage by stage, from pre-seed (neither) to Series B. Read it before you write the job description.
TL;DR: “We need to hire security” is two different sentences wearing one set of clothes. A security engineer builds and fixes: appsec, infra hardening, tooling, the code-level work. A vCISO decides and represents: the program, the priorities, the customer security reviews, the audit strategy. They are not interchangeable, and the wrong first hire is expensive in both directions: a $220K engineer with no program to execute, or a strategist with nobody to implement. The stage answer, compressed: pre-seed, neither. It’s engineering hygiene and founder-owned basics. Seed to pre-Series A selling into the enterprise, vCISO first, because the work at that stage is decisions and paperwork, and the hours don’t justify a full-time anything. Series A with a real attack surface, first security engineer, and the vCISO graduates to advisory. Series B+, a full-time security lead. And yes, I sell vCISO work, so read the bias disclosure below before you take my word for any of it.
Two different jobs wearing one word
When a founder tells me “we need to hire security,” my first question is always the same: do you need someone to build things, or someone to decide things? The blank pause that usually follows is the whole problem.
A security engineer is a builder. They write and review code, harden your infrastructure, wire up your secrets management, tune your dependency scanning, fix the auth bug, build the audit-logging pipeline. Their output is commits, configurations, and closed findings. They are judged the way any engineer is judged: by what ships.
A vCISO, or any security leader, is a decider and a representative. Their output is a program: what you’ll fix and in what order, what you’ll accept and document, what you’ll tell the enterprise customer’s security team on Thursday’s call, how you’ll scope the audit so it unblocks revenue instead of consuming a quarter. They are judged by whether security decisions stop being bottlenecks: whether deals close, audits pass, and the engineering team knows what “secure enough for now” means this quarter.
The market blurs these constantly, because both get filed under “security” in the hiring plan and both cost real money. But they fail differently, they interview differently, and (this is the part that matters) they’re needed at different stages.
The mis-hire, in both directions
Get the order wrong and you pay twice: once in salary, once in the work not getting done.
The engineer with no program. Hire a senior security engineer (call it $220K fully loaded, and that’s not the top of the market) into a 12-person startup with no security program, and you’ve bought a very expensive person who now has to invent their own job. Some can. Most, reasonably, do what engineers do: they pick the technically interesting work. You get a beautifully tuned SIEM and a hand-rolled scanner while the thing actually threatening the company (the enterprise security questionnaire sitting in your sales pipeline, the SOC 2 scoping decision, the access-review policy nobody wrote) sits untouched, because none of that is engineering work. Six months later the founder is confused about why “hiring security” didn’t make the security problems go away. It did, just not their security problems.
The strategist with no hands. The inverse fails just as hard. Bring in security leadership, fractional or otherwise, at a company where the actual gap is implementation, and you get beautifully prioritized findings that nobody fixes. The roadmap says rotate the credentials, isolate the tenants, add the rate limiting. The engineering team, heads down on product, treats it as a wishlist. A vCISO without engineering capacity to direct is a report generator. I say this as someone who writes those reports: the engagement only works if someone on the other side can execute, even if that someone is a product engineer with 20% of their time carved out.
The fix for both failure modes is the same: match the hire to the kind of work your stage actually generates. So let’s do it by stage.
Pre-seed: neither
At pre-seed you do not have a security hiring problem. You have an engineering hygiene problem, and hygiene is not a role. It’s a set of defaults your existing engineers either practice or don’t.
What actually matters here fits on an index card: SSO or a password manager everywhere, MFA enforced, secrets out of the repo and into a manager, dependency updates on, cloud account with billing alerts and no root-key usage, laptops encrypted, and one founder who owns the answer to “what do we do if something leaks.” That founder-owned basics list is boring precisely because it’s effective. The pre-seed incidents I’ve seen were all in the gap between “we knew better” and “nobody owned it.”
Spending real money on security headcount, or even a meaningful fractional engagement, at this stage is solving next year’s problem with this year’s runway. The one exception: if you’re building something regulated from day one (health data, payments infrastructure, kids’ products), the compliance floor arrives before product-market fit does, and you should read the next section as applying to you now.
Seed to pre-Series A: the vCISO, first, and here’s my bias
Full disclosure before this section, because it’s the one that pays my invoices: fractional security leadership is literally what I sell. My consulting practice is built around vCISO engagements for exactly this stage of company. Discount accordingly, and then check the reasoning, because I’ll also tell you below when the answer isn’t a vCISO.
Here’s why the strategist comes first at this stage. Look at what security work a seed-stage company selling into the enterprise actually generates in a given month: a customer security questionnaire (or three), a decision about whether and when to do SOC 2, a vendor review from a prospect’s procurement team, an access-control policy that needs to exist in writing, a prioritization call about which of the 40 scanner findings matter, maybe an architecture review for the feature that touches customer data. Almost none of that is engineering. All of it is decisions and representation, and every piece of it is blocking revenue, not blocking uptime.
That’s a leadership workload, and it’s a part-time leadership workload. There are maybe 15–25 real hours of it a month. A full-time CISO runs $200–400K and is over-leveled for that work in both cost and scope. I’ve done the full cost math on this elsewhere, so I won’t repeat the tables here. The fractional version runs $2–4K/month and covers the actual demand. If you want to know what those hours look like in practice (what actually happens in the first 90 days), I’ve written a week-by-week teardown of a typical engagement.
The other reason the strategist comes first: at this stage, your engineers are your security engineers. A competent product engineer, pointed at a clearly prioritized finding with a clearly articulated “why,” can close most of what a seed-stage company needs closed. What they can’t do is generate the prioritization, or sit on the customer call, or scope the audit.
And if enterprise deals are why you’re here: start with SOC 2 as a revenue tool, because scoping that correctly is the single most valuable decision a vCISO makes at this stage.
When the answer is not a vCISO
Three cases where I’d tell you to skip the engagement I sell:
You have a real-time attack surface from day one. If you’re building deep tech where the product itself is a target the moment it ships (a wallet, an exchange, network infrastructure, anything holding other companies’ credentials), you don’t have a “decisions and paperwork” workload, you have an adversary. That’s an engineering problem first. Hire the security engineer (or make your first ten engineering hires security-strong), and get leadership fractionally on top of that, not instead of it.
You’re regulated from day one. HIPAA, PCI-DSS at level, banking partnerships: when the compliance floor is structural, the work volume justifies dedicated ownership much earlier, and a fractional leader spread across clients may not be able to carry your audit calendar. Some can; be honest about the hours.
You already have a security-strong staff engineer. Some teams get lucky: a staff-level engineer who’s carried security at a previous company and wants the ownership. If that person exists and has the appetite, give them the mandate and 20–30% of their time, and buy them a few advisory hours a month to pressure-test the program instead of a full engagement. That’s cheaper than me, and for the right person it works. The failure mode to watch: the mandate evaporates the first time a product deadline hits. If it happens twice, the experiment failed. Go back to the stage table.
Series A: the first security engineer
Somewhere past Series A the workload flips. You now have real attack surface: more engineers shipping faster than any part-timer can review, customer data at a volume that makes isolation failures existential, infrastructure complex enough that hardening is a project rather than a checklist. The security work stops being mostly decisions and starts being mostly engineering: continuous, hands-on-keyboard engineering.
That’s when the first security engineer earns their seat. And the hire works precisely because the program already exists: they walk into prioritized work with organizational context, not a blank page. The sequencing matters more than the individual. I’ve written about where security fits in the broader pre-Series-A hiring sequence, and the short version is that this hire lands after your core product team is stable, not before.
What happens to the vCISO? The engagement should shrink: advisory hours, audit-cycle support, the customer calls that still need a title. A fractional engagement that’s still running at full intensity eighteen months after a security engineer joined is a smell: either the engineer isn’t being given the program, or the vCISO won’t hand it over. Graduation is the success condition, not churn.
Series B and beyond: the full-time lead
Eventually the decisions themselves become full-time: a security team to manage, quarterly board reporting, a compliance portfolio (SOC 2 plus the customer-specific attestations that enterprise growth accretes), incident process with real stakes, and enough spend to need its own budget owner. That’s a full-time security lead or CISO, and at this point the $200–400K stops being over-leveled and starts being table stakes, because the title now carries work that fills the hours.
The practical note founders miss: your first security engineer is not automatically this person. Sometimes they grow into it; often the builder wants to keep building. Promote for appetite, not tenure, and if you promote, backfill the engineering, because the building didn’t stop.
The decision, compressed
| Stage | First security money goes to | Why |
|---|---|---|
| Pre-seed | Neither (founder-owned hygiene) | The risks are basics, and basics are defaults, not headcount |
| Seed → pre-Series A (enterprise sales) | vCISO / fractional leadership | The workload is decisions + representation, ~15–25 hrs/month |
| Regulated or adversarial from day one | Security engineer (leadership fractional, on top) | The product is a target before it has customers |
| Series A, real attack surface | First security engineer | The work flipped from decisions to engineering |
| Series B+ | Full-time security lead / CISO | The decisions became full-time too |
The one-line version: buy decisions before you buy hands, until the hands are what’s scarce.
If you’re at the stage where the decision is live, run your numbers through the vCISO cost calculator: four questions about your stage, a monthly number out. And if the math points at the fractional route, this is exactly the engagement I run. If it points at the security engineer instead, good. Hire them, and spend the money you saved on making sure they walk into a program instead of a blank page.
Canonical web version: sublimecoding.com/blog/security-engineer-or-vciso-first-hire
How to use this playbook from here
If you've read this far, you have one of three reactions: this isn't relevant to you (no problem, archive the PDF), this is relevant but not yet (bookmark it for the quarter the named enterprise deal lands), or this is the conversation you should be having now.
For the third group: the intro call is the right step. Thirty minutes. Three questions: what's the named deal blocked behind this work, who internally owns security after I'm gone, and what's the budget envelope. We figure out together whether a fractional engagement is the right shape for you, and if it isn't, I'll point you at what is.
Engagement model and the booking link are at sublimecoding.com/consulting.
This playbook is a snapshot. SOC 2 costs, fractional CISO retainers, and graduation thresholds reflect 2025–2026 engagement realities and will drift over time. The web versions of each chapter get edited as the work changes; consult the canonical URLs at the start of each chapter for the current take.