Back to blog

What $12M in Annual Revenue Actually Means

The reality of running a $12M/year business - where the money goes, what it costs, and what's left over.

businessrevenueoperationsfounder-journey

Header image

What $12M in Annual Revenue Actually Means

People hear:

“The platform was doing around $12M a year.”

And their brain jumps straight to:

“You must have been printing money.”

Reality is a lot less glamorous and a lot more sobering.

Top-line revenue is a vanity number if you don’t understand:

  • Where it actually comes from
  • What it costs to produce
  • How much risk and overhead sit underneath it
  • What ends up in the founder’s pocket (spoiler: it’s not $12M)

This isn’t a brag post. It’s a reality check.

1. The Real Numbers (Directionally, Not for Court Testimony)

Conductor was doing eight-figure annual revenue in its mature phase.
Think:

  • Solid, recurring, contract-driven revenue
  • Long-term customers
  • Real money flowing through the pipes every single day

Was it exactly $12M, which year, gross/net, etc.?
Not going there. The exacts are between contracts, accountants, and buyers.

What matters more for this conversation:

  • It wasn’t a “cute little side project”
  • It wasn’t a “unicorn”
  • It was a real, boring, operational backbone with serious volume and matching responsibility

And like most boring, real businesses, the economics were more complex than:

“Number big → founder rich.”

2. Where That Revenue Actually Came From

Rough shape:

  • Recurring platform fees

    • Think: subscription-style or license-style revenue
    • Customers paying to have the system live, integrated, and supported

  • Per-transaction / per-usage components

    • More usage = more revenue
    • But also more load, more support, more everything

  • Implementation / onboarding work

    • One-time or project-based chunks
    • Heavy up-front effort to:
      • Integrate with back-office systems
      • Handle data conversion
      • Customize workflows

  • Support / managed services layers

    • Extra revenue tied to:
      • Higher SLAs
      • Deeper integration help
      • “We don’t just give you software; we make sure it works in your world”

This was not consumer SaaS with 50,000 $29/mo users.

This was fewer customers, deeper relationships, high expectations, and real operational impact.

3. Where the Money Went

Here’s the part people don’t see.

Big buckets:

  1. Staffing (by far the biggest)

    • Engineers (backend, integrations, devops, QA)
    • Ops/support staff
    • Account management / customer success
    • Compliance / admin / finance
      Payroll is the monster in any serious B2B platform.

  2. Infrastructure and tooling

    • Servers, databases, storage
    • Monitoring, alerting, logging
    • Backup, DR, security tooling
    • Third-party integrations and licenses

  3. Compliance and regulatory overhead (healthcare makes this special)

    • HIPAA-related controls and processes
    • Legal review
    • Security assessments
    • Documentation and policy maintenance

  4. R&D / Product development

    • Building new features
    • Re-architecting pieces to scale or meet new requirements
    • Experiments that never shipped but still cost real engineering time

  5. Insurance, legal, and “you don’t think about this at MVP time”

    • Professional liability / E&O
    • Contracts and negotiations
    • Accounting and audit work

After all that, the "$12M" starts looking a lot smaller.

The funnel

4. What the Founder Actually Takes Home

This is the part everyone fantasizes about.

No, I’m not dumping exact tax returns here. But I’ll give you the shape of it.

Key truths:

  • Founder income does not scale linearly with top-line revenue.
  • In heavy, long-term platforms like this, you often:
    • Pay your people
    • Pay your vendors
    • Invest in product
    • Build buffers
    • And whatever’s left is what you can safely take without crippling the business

There are years where:

  • The business looks big on paper
  • But you’re taking home something that’s a lot closer to:
    • “Well-paid senior engineer”
    • Than “TV show CEO”

Some years you do better. Some years you deliberately ratchet down your own comp because:

  • A big customer needs a custom integration
  • Infra spend spikes
  • You’re doing a strategic rebuild/refactor
  • You’re absorbing a hit instead of letting the product slip

Point being:

“$12M in revenue” and “founder is taking home millions a year”
are not the same story.

5. How Margins Shift as You Scale

There are phases:

Early stage (sub-$1M to a few $M)

  • Every dollar feels huge.
  • Margins are often weak because:
    • High engineering spend
    • Platform still being hardened
    • Revenue not yet stable or predictable
  • A single customer churning hurts.

Mid-stage (serious but not huge)

  • Revenue stabilizes.
  • Infrastructure cost per dollar of revenue can improve.
  • But:
    • Enterprise expectations rise
    • Compliance and support obligations grow
    • You start hiring more “glue people” (ops, support, finance, CS)

Mature phase (high single-digit to low double-digit millions)

  • You finally have enough volume to look “big” from the outside.
  • Margins are better if:
    • You keep headcount disciplined
    • You don’t drown in bespoke “just for this one customer” work
  • Margins get crushed if:
    • You say yes to everything
    • You do too much custom
    • You layer human process on top of bad architecture

In other words:

More revenue doesn’t automatically mean “more free cash.”
Sometimes it means “you just signed up for more obligations.”

6. The Healthcare Tech Penalty

Healthcare tech is not sexy.

Here’s what that means in practice:

  • HIPAA and state regulations add:
    • Process overhead
    • Documentation overhead
    • Legal overhead
  • Auditability matters:
    • You can’t hand-wave logs
    • You can’t ignore data lineage
    • “We’ll fix it later” can translate into “we’ll explain it to a regulator”

Every one of those:

  • Consumes engineering time
  • Requires more careful infrastructure
  • Shrinks the pool of things you can cheaply outsource or offshore

In some SaaS verticals you can get away with “move fast, break things.”

In healthcare:

Move too fast, break the wrong thing, and you’re in court or in front of an agency.

That overhead doesn’t show up in the big “$12M” number.
It lives in salary lines, consulting bills, and time you don’t spend building the flashy features people think you’re doing.

7. Staffing: The Hidden Gravity Well

At peak, the team was big enough that:

  • Payroll was the single largest expense line by a wide margin.
  • You’re not just paying:
    • Base salaries
    • You’re paying:
      • Benefits
      • Taxes
      • Tools
      • Office/remote overhead
      • The cost of time lost to meetings, onboarding, and coordination

A typical serious B2B platform can easily run:

  • 50–70% of revenue into compensation + directly related overhead
    (directional, not a formula)

Healthcare doesn’t help that; if anything it pushes it up because:

  • You need more senior people
  • You need people who can handle regulated environments
  • You can’t staff everything with the cheapest talent you can find

So when someone hears:

“We were doing around $12M annually.”

The correct mental translation is:

“We were paying a lot of skilled humans every month to keep a complex machine running in a regulated environment.”

Not:

“We had $12M sitting in a pile.”

8. Infrastructure and Technical Overhead

This part gets ignored because “cloud is cheap.”

Cloud is not cheap when:

  • You have to run:
    • Multiple environments
    • Serious databases
    • Redundancy and DR
  • You can’t gamble with:
    • Backups
    • Monitoring
    • Latency spikes during critical windows

Infra spend includes:

  • Core hosting / compute / DB
  • Storage (including historical data you absolutely must keep)
  • Backup + DR
  • Monitoring and observability tooling
  • Security layers
  • Third-party services:
    • Email, SMS, logging, auth, payment, etc.

Is infra the biggest cost? No.
But is it trivial? Absolutely not.

And again, healthcare doesn’t let you be sloppy.

9. Why Revenue ≠ Success

Here’s what non-technical and non-operator types often miss:

  • Revenue is obligation.
    Every dollar of ARR comes with:

    • SLAs
    • Contract terms
    • Support expectations
    • Legal risk

  • Revenue is complexity.
    The more customers, edge cases, integrations, and special deals you have, the more:

    • Conditionals appear in your code
    • Exceptions appear in your process
    • Mental overhead your team carries

  • Revenue is not automatically freedom.
    When the system is critical to customers:

    • You don’t just “take a month off”
    • You don’t “turn it off and pivot”
    • You have to respect the responsibilities you signed up for

Success isn’t:

  • “We hit $XM.”

Success is more like:

  • “We built something that:
    • works reliably,
    • serves customers well,
    • doesn’t destroy the people running it,
    • and leaves enough on the table to be worth the pain.”

That’s a much higher bar than “top-line looks good.”

10. If I Did It Again: What I’d Change

Knowing what I know now, a few levers I’d lean on harder:

  1. Stricter product boundaries

    • Fewer special cases
    • Fewer “one-off” features for specific customers
    • More “this is how the product works, and here’s why that’s actually in your best interest”

  2. More brutal architecture discipline early

    • Even more emphasis on:
      • Multi-tenant design
      • Clean integration boundaries
      • Observability from day one
    • Every corner cut early becomes:
      • Human labor later
      • Night/weekend work later
      • Margin compression later

  3. Deliberate margin targets

    • Designing the business around:
      • “We will hit X% margin and we will say no to business that destroys that.”
    • Harder in healthcare, but still worth pushing for.

  4. Treating founder time as a cost, not a sink

    • Being more explicit that:
      • Founder time is not “free”
      • Burning yourself out to keep margins up is not winning

Was the model “wrong” for the market?
No. In many ways it was exactly the kind of model you need in healthcare:

  • Stable
  • Serious
  • Reliable

But if you look at “$12M/year” and think:

“I want that,”

you should be very clear about what that number actually represents:

  • A lot of people
  • A lot of responsibility
  • A lot of risk
  • And a lot of invisible cost before you ever talk about “profit”

Top-line figures are fun to say out loud.

They are terrible tools for understanding what a business really feels like from the inside.

Context → Decision → Outcome → Metric

  • Context: B2B healthcare platform hitting ~$12M annual revenue, with all the hidden costs: staffing 50-70% of revenue, compliance overhead, infrastructure, and founder time absorbed into keeping the machine running.
  • Decision: Ran the business for stability and margin discipline rather than hypergrowth. Said no to custom work that destroyed margins. Treated founder time as a real cost, not a free resource.
  • Outcome: Built a sustainable, sellable business rather than a revenue trap that looked good on paper but bled cash. Avoided the "big number, no profit" trap common in B2B.
  • Metric: Consistent profitability through cycles. Founder compensation that was livable (not millions, but not ramen). Clean enough books and margins to support an eventual sale.

Anecdote: The Year Revenue Went Up and Stress Went Up More

In 2016, we landed a large new contract. Revenue jumped significantly. The team celebrated.

Six months later, I was working more hours than ever. We'd hired three new people. Infrastructure costs had spiked. The new client had endless customization requests that we'd agreed to in the contract.

By the end of the year, the margin on that contract was barely positive. The "big win" had actually made the business harder to run while barely moving the bottom line.

That year taught me: revenue without margin discipline is just trading your life for a bigger number on a spreadsheet.

Anecdote: The Month I Paid Myself Less Than My Junior Dev

There was a month in 2013 where cash flow got tight. A payment was delayed. A big infrastructure bill hit at the wrong time.

I looked at the options: delay paying vendors (bad for relationships), delay paying staff (illegal and wrong), or reduce my own draw.

I took a tiny draw that month. Less than what I was paying my most junior developer.

That's the reality of "$12M revenue" that nobody sees from the outside. Some months, the person at the top is the one who doesn't get paid because everyone else has to get paid first.

The vanity metric didn't help. Cash flow reality did.

Mini Checklist: Understanding What Revenue Actually Means

  • [ ] Know where revenue comes from: recurring vs. one-time vs. usage-based
  • [ ] Know where revenue goes: staffing, infrastructure, compliance, R&D, insurance, legal
  • [ ] Track margin, not just top-line: revenue without profit is just expensive exercise
  • [ ] Treat founder time as a real cost: burning yourself out doesn't make the math work
  • [ ] Set product boundaries: say no to custom work that destroys margins
  • [ ] Prepare for the "big contract, bigger stress" scenario: more revenue often means more obligation
  • [ ] Remember: revenue is obligation, complexity, and risk—not just money
Back to blog