Finance for general contractors

What this actually looks like, cycle to cycle

Around the 25th of each month, project managers finalize their pay applications for the period. Over the next few days, someone — a project accountant, a controller, sometimes an owner directly on a smaller firm — checks each one against its contract and schedule of values, confirms retainage is being withheld correctly, and reconciles any subcontractor invoices that came in for the same period.

None of this is complicated in isolation. What makes it a real job is the repetition across every active project, the accumulation of contract-specific quirks — a step-down here, a bonded reduction there — and the fact that a missed discrepancy doesn't announce itself until months later, at final retainage release or a bonding review.

Who ends up running this

At a small firm, it's often the owner or a bookkeeper wearing several hats, squeezing pay application review in around estimating and site visits. At a mid-sized firm, it's usually a dedicated project accountant or controller, sometimes one per few projects. At a larger firm, it's a project accounting team with defined roles — someone checking pay applications, someone else tracking retainage across the portfolio, someone reconciling subcontractor invoices.

The size of the team changes, but the underlying job doesn't — every one of those roles is checking the same three things: does the pay application match the contract, is retainage tracked correctly, and does what a sub billed match what was billed for their scope.

The core loop

flowparse.io

The questions ownership actually asks

Not "show me a report" — specific questions, usually with some urgency behind them. How much retainage do we currently have tied up across all active projects? Is this pay application ready to submit, or does something need checking first? If we lost our project accountant tomorrow, could someone else pick this up without starting from zero?

A firm with a real routine answers all three quickly, because the running balances and checked history already exist. A firm without one answers with "let me pull that together," which is exactly the moment ownership starts asking whether the current process is actually working.

One project, worked through

A $2.4M commercial build, 14 months, 22-line schedule of values, an 18% blended average across nine active subcontractors.

By the time substantial completion was declared, the final retainage release amount was already a known figure, checked against twelve months of pay applications rather than reconstructed from scratch — the difference between a routine closeout and a weeks-long reconciliation project.

When there's a whole portfolio, not one job

A firm running eight active projects at once faces this problem multiplied — eight contracts, eight schedules of values, eight retainage terms, and no single view naturally showing all of them without deliberate effort to build one.

Each project is checked on its own terms, and the results roll up into one portfolio view — total retainage held across every job, alongside the detail for any single project when a specific question needs it. That portfolio view is exactly what turns “how much retainage do we have tied up” from a multi-day research project into an answer available the moment it's asked.

Built to survive staff turnover

Project accounting roles turn over — someone leaves, someone gets promoted into a different role, a firm grows past what one person can track in their head. When the process lives in a checked, running record rather than one person's memory of which projects have unusual retainage terms, a new hire can pick up the work without months of context transfer.

This is one of the more underrated benefits, because it rarely comes up until the moment it's needed — and by then, a firm that built the habit early is the one whose transition goes smoothly.

This sits under your construction ERP

Procore, Sage 300 CRE, Viewpoint and similar systems handle project management, job costing and often pay application preparation itself. What they don't always do well is an independent check of whether a prepared pay application actually reconciles against the contract and prior periods — the system trusts what's entered into it, because that's not the job it was built for.

This sits underneath that system, reading the documents it produces and checking them against the contract independently — a second set of eyes that doesn't replace the ERP, and doesn't require replacing it to add value.

flowparse.io

A three-job GC and a thirty-job GC aren't that different

A small firm running two or three projects has less volume, but the same underlying check applies to each one — a pay application still needs to be verified against its contract regardless of how many other projects exist alongside it. The difference is mostly in whether a portfolio-level rollup matters yet, not in whether the core checking job is worth doing.

A larger firm running thirty projects needs that portfolio rollup badly, because no single person can hold thirty contracts' worth of retainage terms in their head — but the per-project mechanics are identical to what the three-job firm needs. Scale changes how much the aggregation matters, not what the underlying job actually is.

What this doesn't do

Getting started without disrupting anything

The lowest-friction start is running the check alongside whatever process already exists, on one active project, for one billing cycle — not switching over the whole portfolio on day one. Compare the results against what the existing process would have produced, and build confidence from there.

Nothing about starting this way requires changing how pay applications are prepared, how subcontractors invoice, or what ERP the firm runs. It reads the documents already being produced — the only new step is uploading them somewhere they get an independent check.

The range of contractors this covers

Feeding the bonding company's questions

A surety reviewing a contractor's bonding capacity asks pointed questions about work in progress — how much retainage is tied up, how current the billing is against actual progress, whether any project is showing signs of overbilling. Answering those questions from a checked, current running balance is a fundamentally different conversation than reconstructing the answer from scratch under deadline pressure.

Firms that keep this current find bonding reviews go faster and raise fewer follow-up questions — not because the underlying business changed, but because the numbers were already there, checked, when the surety asked for them.

What actually changes, concretely

The most visible change is time — hours per billing cycle spent manually checking pay applications and subcontractor invoices drop substantially once the line-by-line checking is automatic rather than manual. The less visible but more valuable change is what gets caught: overbilled lines, unrecorded change orders, retainage rate errors that would otherwise surface only at final release, months after they'd have been cheap and easy to fix.

Neither change requires an all-at-once transformation. Most firms notice the time savings within the first couple of billing cycles, and the caught-error value accumulates quietly — the retainage discrepancy that never became a dispute, the overbilling that got corrected before it reached the owner.

A few common scenarios

flowparse.io

Splitting the work with a team

At a firm large enough to have a project accounting team, the roles typically split along the same lines as the core loop itself — one person primarily checking pay applications against contracts, another focused on the portfolio-wide retainage rollup, a third handling subcontractor invoice reconciliation across the busiest trades.

None of those roles need to work from a different source of truth — the same checked pay applications and running balances feed all three, which is what keeps the team's combined output consistent instead of three separate, occasionally conflicting versions of the same numbers.

How this changes conversations with subcontractors

A subcontractor whose invoice has been checked against the schedule of values before a payment conversation happens gets a precise answer — this line matches, this one doesn't and here's why — instead of a vague “we'll look into it” that stretches into weeks. That precision tends to build trust with subs faster than good intentions alone — the mechanics behind it are covered in subcontractor invoice reconciliation.

For subs themselves, a GC with a consistent, checked billing process is a meaningfully different partner to work with than one whose payment timing and accuracy vary by which project manager happens to be handling a given job — the kind of reputation that affects which subs bid a firm's future work.

Feeding better cash flow decisions, not just cleaner books

A current, accurate view of retainage held across every active project is also a cash flow input — retainage due for release is money the firm can plan around, and a firm that doesn't track it precisely tends to either underestimate available cash or get surprised by a release that lands later than expected.

That planning value compounds across a portfolio — knowing which of eight projects has retainage coming due next quarter, and roughly how much, turns cash flow forecasting from a guess into a number backed by actual contract terms and actual progress.

Feeding the year-end close

Percentage-of-completion revenue recognition, WIP schedules and job costing all depend on accurate, current billing data — the same pay applications and retainage balances this routine checks all year feed directly into that close, rather than needing to be reconstructed or verified fresh at year end.

A firm that's kept this current all year hands its CPA a clean, checked set of project data at close time. A firm that hasn't spends the close reconciling twelve months of pay applications it should have checked as they happened — the same work, just compressed into the worst possible window to do it.

Onboarding a new project manager

A newly hired project manager, especially one coming from a firm with different billing conventions, doesn't arrive already knowing this firm's retainage step-down triggers, its schedule-of-values conventions, or which projects have unusual contract terms. Their first few pay applications are the highest-risk period for exactly the kind of error a checked routine is built to catch.

A firm with an established checking process treats those first pay applications the same as any other — checked against the contract, flagged where something doesn't tie out — which turns a new project manager's learning curve into a series of caught, correctable mistakes rather than a source of undetected errors that surface months later at a project's worst possible moment to discover them.

Running lump-sum and cost-plus contracts side by side

Not every project a GC runs uses the same contract structure. A lump-sum contract bills against a fixed schedule of values, while a cost-plus contract with a guaranteed maximum price bills against actual costs plus a fee, subject to a different kind of tracking entirely — and a firm running both types at once needs its project accounting to handle each correctly rather than forcing every project through the same lump-sum-shaped process.

The checking approach adapts to whichever structure a given contract actually uses, reading each project's own governing document rather than assuming a single billing method applies portfolio-wide — a firm doesn't need to standardize its contract types before this becomes useful, only be consistent about checking each project against the terms that specific contract actually specifies.

What this changes in conversations with the owner

An owner or their architect reviewing a pay application before certifying it asks some version of the same question every month: does this billing actually reflect the work completed. A GC who can answer confidently, backed by a check already run against the schedule of values, moves through certification faster than one whose answer is essentially trust in the project manager's own estimate.

That speed compounds across a project's full duration — a pay application that gets questioned and delayed even a few days each cycle adds up to real cash flow impact over a year-long project, while one that's consistently well-supported tends to move through certification close to on schedule every single time.

Frequently asked questions

Keep reading