The financial model most founders build wrong (and how to fix it)

The short version:

• Most founders who build a financial model build it once, for a raise or a board meeting, and then never feed it real numbers again. A model you don't update isn't a plan. It's a guess with decimal places.
• A model's value was never the forecast (which is wrong within weeks). It's that it writes your assumptions down where reality can prove them wrong. That only works if you actually check the assumptions against what happened.
• Checking requires actuals: clean, current books. This is the step a16z's own commenters flag as the one founders skip. They build the model but never capture the base numbers, so the loop never closes and the model dies quietly.
• The habit that matters isn't modeling. It's reconciling the model to reality on a schedule, so the gaps between assumption and actual become the questions that run your business.

Ask a pre-seed or seed founder why they don't have a financial model and you'll usually hear a version of the same thing: we're too early. Customers are still forming, pricing is provisional, the growth channels are unproven, so any model built now will be wrong within weeks, and why manufacture false precision that will only embarrass you in front of investors? Modeling gets pushed to "later," once the business feels more real.

a16z's speedrun team took this objection head-on in a recent essay, The Number One Tool Early Stage Founders Overlook, and their answer is correct: you're not too early. The point of an early model was never an accurate forecast. It's that building one forces you to make your assumptions explicit, to write down a CAC, a conversion rate, a retention curve, so reality can later prove them wrong. A refusal to think structurally about an uncertain future, as they put it, is one of the strongest predictors of failure. Build the model. That part of the debate is settled.

But here's where "build a model" turns out to be only half the advice, and the missing half is where most founders actually fail. Being talked into building a model gets you a spreadsheet. It does not get you the learning the model was supposed to produce, because a model only teaches you anything when you check its assumptions against what really happened. And checking is the step almost everyone skips.

A founder raising a seed round builds the model. It's real work: revenue ramping, CAC around $40, a clean retention curve, burn and runway laid out for two years. It helps close the round. Then it goes into a folder called "Fundraise" and is never opened again. Nine months later, trying to work out why runway is vanishing faster than planned, they reopen it, and every assumption is stale. CAC came in at triple what they'd typed. The ramp was slower. A cost line they'd guessed at doubled. None of it was ever corrected, because no real number was ever placed next to a projected one. The model didn't get them lost. It just stopped telling them anything the day they finished building it.

That's the financial-model failure that actually costs founders, and it sits one step past the debate a16z settled. Not the founders who never built a model, the far larger group who built one, used it to raise, and never fed it a real number again. A model you don't update isn't a plan. It's a guess with decimal places.

The forecast was never the point

To see why the dead model is such a waste, follow the logic of the explicit-assumptions argument one step further than it's usually taken.

The reason writing down your assumptions helps is that it lets reality argue with them. When your CAC lands at $120 instead of the $40 you modeled, you don't have a fuzzy sense that things are harder than hoped. You have a precise, located signal: this assumption is broken, by this much, here. The model turned an uneasy feeling into a question you can work on.

But notice what that signal depends on. It only exists if someone puts the real $120 next to the projected $40. A model with no actuals flowing into it can never be contradicted, which sounds comfortable and is exactly the problem, because a claim that can't be checked can't teach you anything. Making assumptions explicit is step one. Confronting them with reality is step two, and step two is the one that produces all the learning. Skip it and you've done the fun half of the work and thrown away the half that mattered.

The step everyone skips: the actuals

When investors write about modeling, the top response from operators is some version of: the output barely matters, what matters is revisiting the assumptions against actuals, and that assumes you're systematically capturing the actuals, which is the part people miss. Miss it, and most of the model's value is lost.

That's exactly it. A model is a hypothesis. Your books are the experiment that tests it. Founders love building the hypothesis, it's the fun part, the part where the business looks like it works on a screen. Running the experiment is the unglamorous part: closing the month, categorizing every transaction, reconciling the accounts, producing a true number for what you actually spent and earned and burned. Without that, there's nothing to test the hypothesis against, and the model degrades from a learning instrument into a comforting story you told an investor once.

The two halves are useless apart. Actuals without a model are just history: you know what happened but not what it means for what you believed. A model without actuals is just fiction: a confident narrative accountable to nothing. The value lives entirely in the loop between them, and the loop only closes if the books are clean enough and current enough to plug in.

Closing the loop: model, meet reality

The practice that makes a model earn its keep isn't modeling. It's reconciliation: comparing plan to actual, on a schedule, and letting the gaps drive what you do next.

Concretely, that means a rhythm. Each month, when the books close, you put the real numbers next to the assumed ones. Where did burn land against plan? What was CAC, really? Did the cohort retain the way you assumed? For each material gap, you ask one question: is this noise, or is this a broken assumption? Noise you note and move on from. A broken assumption you update in the model, and, more importantly, you ask what it means. A CAC that's tripled isn't just a cell to change. It's a signal that a growth channel isn't working, or pricing is off, or the ICP is wrong, discovered while you still have runway to respond.

Done this way, the model becomes a living document in the true sense. Not "we revisit it before each board meeting," but a standing dialogue between what you believed and what's true. The founders who do this don't have better foresight than the ones who don't. They just have a shorter lag between a wrong assumption and the moment they notice it's wrong, which at early stage is most of what survival is.

There's a useful discipline in keeping the model small enough to actually maintain. You don't need a three-statement, GAAP-perfect model at seed. You need cash in, cash out, burn, runway, and a handful of the assumptions that decide whether the business works, few enough that updating them monthly is a habit rather than a project. A simple model you reconcile every month beats an elaborate one you build once and abandon, every time.

What this actually takes

The bottleneck, then, isn't spreadsheet skill. It's the reliable supply of actuals, and that's a books problem, not a modeling problem.

Keep the books current enough to produce real numbers on a monthly cadence, because a model reconciled against three-month-old books is reconciled against fog. Close the month on a schedule rather than when you get around to it, so the actuals arrive in time to be useful. Track the model's few key assumptions as named line items you can pull straight from the books, burn, revenue, CAC, retention, rather than reconstructing them each time. And when an assumption breaks, treat it as a prompt to investigate the business, not just to edit a cell. The number changing is the least interesting part. What it tells you about your company is the point.

None of this is heavy. It's the same monthly-close discipline that keeps you filing-ready and raise-ready, pointed at one more use: feeding the loop that tells you, early, when a belief you're running the company on has stopped being true.

How this looks in practice

We built Inkle around the unglamorous half of this. Inkle handles accounting, bookkeeping, tax, and compliance for US startups, and Inkle Books is designed to be the actuals engine a model needs. It connects to your banks and cards, categorizes transactions automatically, and closes your books with expert help, then surfaces your real burn rate, runway, and cash position in real time, alongside cash flow statements and trends you can compare period over period. In other words, it produces the true numbers, the experiment, that a model's assumptions are supposed to be tested against, without a spreadsheet fire drill each month.

The pattern we see is that founders rarely lack for models. They lack for reliable numbers to test them with. Once the close is dependable and burn and runway are current at a glance, the model stops being a document dusted off for board meetings and becomes something a founder can run the month against. For cross-border teams the actuals are harder to assemble, spanning more than one system and currency, which is exactly why having them owned reliably matters more, not less. The outcome isn't dramatic. It's a founder who notices a broken assumption in week two of a month instead of in the middle of a raise.

The takeaway

Build the model. The debate about whether you're too early is settled, and you're not. But understand what you're building: not a forecast, and not a document for investors, but a set of testable claims about your business. A claim you never test is worthless, and testing needs actuals, which means the real work isn't in the modeling at all. It's in the boring, monthly discipline of producing clean numbers and holding them up against what you believed. A model is a hypothesis. Your books are the experiment. Run both, or you're not modeling. You're just guessing, with decimals.

Frequently asked questions

Do seed-stage startups need a financial model? 

Yes, but not for the reason founders assume. The value isn't an accurate forecast, a seed-stage forecast will be wrong within weeks, it's that building the model forces you to state explicitly what has to be true for the business to work (CAC, conversion, retention, pricing). Those explicit assumptions become testable, so reality can tell you which beliefs are broken while you still have runway to respond.

How often should I update my startup's financial model? 

Every month, tied to your books closing. The point of a model is the loop between what you assumed and what actually happened, and that loop only closes when you compare plan to actuals on a regular cadence. A model updated once for a fundraise and then abandoned quickly becomes fiction. A simple one reconciled monthly is far more valuable than an elaborate one built once.

What should a seed-stage financial model include? 

Keep it small enough to maintain: cash in, cash out, monthly burn, runway over the next twelve months, and a handful of the assumptions that decide whether the business works, typically CAC, conversion, retention, and price. You don't need a three-statement, GAAP-perfect model at seed. You need few enough moving parts that updating them monthly is a habit rather than a project.

Why is my financial model always wrong? 

Because a forecast under uncertainty is supposed to be wrong. Accuracy was never the goal. The mistake isn't that the numbers miss. It's failing to compare them to actuals and update. A model earns its value when a gap between assumption and reality (say, CAC landing at $120 instead of $40) becomes a located signal you can act on, rather than a prediction you hoped would come true.

What's the difference between a financial model and actuals? 

A model is a hypothesis: your assumptions about how the business will behave. Actuals are what actually happened, produced by your bookkeeping and monthly close. The two are useless apart: actuals alone tell you history without meaning, and a model alone is a story accountable to nothing. The value comes from the loop, testing the model's assumptions against the actuals and updating both.