Every carrier, MGA, and wholesaler eventually faces the same crossroads: Do we build our own billing system, buy something off the shelf, or outsource the function altogether?

Each option looks reasonable on paper. Each comes with hidden costs. And the real difference between them has less to do with software than with fluency — fluency in how money actually moves through insurance.

The companies that get billing right don’t just have better systems; they have better operational logic. They understand that billing isn’t a tool. It’s the lifeblood of the business.

Why So Many Try to Build

It’s easy to see why the instinct to build runs deep. Insurance operators are used to solving complex problems in-house. You already have engineers, a PAS, and a finance team drowning in reconciliation tasks. On the surface, billing looks like a tractable automation problem — something a few developers and a Stripe integration could hypothetically solve.

The reality is different. Billing in insurance isn’t a technical exercise; it’s an operational and accounting discipline. Every premium dollar must travel through multiple entities — insured, agent, MGA, carrier, reinsurer — and every move creates a liability, a receivable, and an audit trail. The system has to understand not just who pays, but why, when, and how that movement affects trust down the chain.

Without that domain logic, homegrown builds collapse under the weight of exceptions:

• A mid-term cancellation triggers a return premium that offsets a previously remitted commission.
• A partial ACH payment requires split allocation across policy endorsements.
• A wholesaler and MGA dispute whose fee was applied first, delaying settlement.
• A surplus lines tax was miscategorized, throwing off reconciliation for an entire month.‍

These aren’t bugs. They’re the business itself.

The reason many “internal” billing systems fail is that they try to code around these realities instead of architecting for them.

Every policy event is at least one financial event, and often several. A single bind, endorsement, or cancellation can trigger multiple receivable and payable movements, especially under installment or premium finance arrangements. Even a full-pay policy sets off a sequence: cash in from the insured, commissions out to producers, remittances up to carriers, and sometimes adjustments down the line. Each of those flows requires matching logic across billing, cash application, and partner payables. Miss one link, and reconciliation turns manual.

• That’s why 86% of payments in insurance still require human intervention.
• That’s why the average cost per payment exceeds $18.
• That’s why billions in liquidity sit idle across the ecosystem every month.

The Buy Illusion

The alternative — buying — often looks safer. Modern PAS vendors now advertise “billing and payments” modules and promise an integrated experience. On a demo, that veneer looks complete: invoices flow out, payments come in, and balances sync with the GL.

But integration is not understanding.

Most billing modules can issue an invoice and record a payment. Very few understand the financial destiny that begins with a single policy event — how that one bind or endorsement creates a sequence of receivables and payables that unfold over time, and how future events reshape that sequence. A real billing system has to know not just that money moved, but why, where it’s headed next, and how each movement changes what’s owed across agencies, MGAs, and carriers. That’s the difference between a system that simply tracks payments and one that actually governs them.

The problem is structural. CFOs trained in investment finance rather than operational finance often evaluate systems based on surface features, not subledger integrity. They assume “billing” means “invoicing.” They don’t ask the questions that actually test financial readiness:

• What happens when a payment fails or a policy reinstates?
• How are carrier payables recalculated when premiums are adjusted mid-term?
• Can the system reconcile by transaction across entities — not just by batch or account?
• What happens when a refund affects a prior period close?

Those questions separate billing software from billing infrastructure.

The consequence of skipping them is predictable. The company ends up with a “billing module” that looks integrated but can’t reconcile. Finance spends 20+ hours a month closing the books. DSO creeps up. Partner trust erodes. And the next time someone says, “we need better billing,” the cycle starts over.

The Third Path: Borrow the Expertise

There’s a growing recognition that billing can’t be fully solved by tools alone. It’s a discipline that combines software, process, and judgment.

That’s where the third option — borrow — comes in.

Borrowing doesn’t mean outsourcing responsibility. It means partnering with specialists who already know the domain. Instead of building or buying, you run your billing, payments, cash application, and distribution partner payables through a platform built explicitly for insurance money movement — and, if needed, you let that same team operate it for you as a managed service.

In practice, this model has several advantages:

• You inherit battle-tested logic for agency bill, direct bill, and premium finance flows.
• Your financial close accelerates from weeks to days because cash app and reconciliation are built in.
• You can launch new products, programs, or billing models without re-architecting core systems.
• You gain transparency across receivables, payables, and trust accounts — a single operational ledger for every dollar in motion.

It’s also pragmatic. Functional Finance defines the core pillars of billing at scale as:

1. Billing and invoicing
2. Payments
3. Cash application
4. Reporting
5. Distribution partner payables

Everything else — custom workflows, portals, even surplus lines tax filing — could be handled as BPO. That’s how operators are considering efficient scale: run your core logic on purpose-built infrastructure, and outsource the labor that doesn’t differentiate you.

This isn’t theory; it’s where the market is heading.

MGAs and carriers are starting to recognize that the most expensive billing systems are the ones that still require headcount to close what automation should have finished.

The Real Decision

So, how should an operator decide?

Forget the labels. Forget “build” versus “buy.” The real question is governance:

• Who owns the logic that decides how money moves?
• Who maintains auditability when transactions cross entities?
• Who can intervene when something breaks?

If the answer is “nobody knows,” then you don’t have a billing system — you have a liability system. And the hard truth is that very few people can build this at all. Insurance billing isn’t a set of static rules; it’s a living framework of exceptions, adjustments, and dependencies that shift every time a policy event occurs.

• Building means owning every rule, exception, and correction it will ever need. That level of control sounds empowering until you realize it never ends. The logic keeps changing — new products, new programs, new states — and someone has to understand and update it without breaking the chain.
• Buying means you inherit someone else’s assumptions about billing logic, and those assumptions rarely fit the way your receivables and payables actually behave.
• Borrowing keeps oversight of the financial truth, but relies on specialists who already understand how to encode it, test it, and adapt it safely over time.

At Functional Finance, we talk about “automating all money movement in insurance.” That vision isn’t about software alone. It’s about restoring clarity to how premiums, commissions, and capacity provider payables actually work. Because in the end, what every insurer wants is the same thing: to know, with certainty, where their money is.

A Final Lens for Decision-Makers

Before choosing a path, ask yourself:

• Can you close the books within five business days?
• Are partner statements always accurate and on time?
• Is more than 20 hours per month spent on manual reconciliation?
• Can you see, in real time, every dollar in motion across entities and programs?

If not, you don’t just need new billing software. You need financial infrastructure that actually functions.

Across operators we’ve studied, solving those inefficiencies pays for itself within 9–15 months — often faster when payment processing and distribution flows are automated.

Here’s the simplest test before you choose your path:

‍

If you’re serious about growth, your operations have to scale as fast as your distribution. That doesn’t happen through one-off projects. It happens through systems that make billing reliable infrastructure instead of recurring pain.

Because in insurance, billing isn’t a back-office function. It’s how money, trust, and growth all flow.