What building a rate schedule actually involves
Building an indirect cost rate schedule sounds, described in one sentence, like a data entry task: collect the invoices, code them, add them up, divide. In practice it's a small process with real judgment calls at almost every step — which pool a specific invoice belongs to, whether a cost is allowable, how to handle a document that can't be located.
This guide breaks that process into nine steps, in the order they actually happen for most government contractors and the CPA firms that support them, whether the work is done entirely by hand, with a spreadsheet and some discipline, or with software that reads each document automatically. The steps are the same regardless of which — what changes is how much of each step is manual.
Read them in order the first time, then treat them as a checklist for every subsequent fiscal year — the value compounds once the same nine steps become routine rather than something re-derived from first principles every year.
Why the process matters more than the spreadsheet
Almost every contractor already has a spreadsheet or a rate-schedule template that can hold the final pool and base totals once the figures are in it. The actual point of failure is rarely the template — it's the process of getting accurate, correctly coded figures into it consistently, year after year, without the small errors that accumulate when the same manual task is repeated under a recurring deadline.
That distinction — template versus process — is worth keeping in mind through every step below.
A disciplined process, followed the same way every fiscal year, catches most of what goes wrong before it reaches the final submission. That's the actual value of the nine steps below — not a new template, but a routine that makes the same mistake hard to repeat twice.
It's worth saying plainly: none of the nine steps below are complicated in isolation. What makes rate-schedule preparation hard in practice is doing all nine, correctly, every single fiscal year, without skipping one under time pressure — which is a discipline problem more than a technical one, and exactly why a written process helps even when everyone involved already knows what to do in principle.
Confirm your pool structure and allocation bases
Before collecting a single invoice, confirm exactly which pools the schedule will use — fringe, overhead, G&A, and any others specific to your business — and which base each one is allocated over. This structure should already exist from your cost accounting policy or disclosure statement; this step is about confirming it hasn't changed, not designing it from scratch each year.
A new cost center added mid-year, or a reorganization that shifted which department a cost belongs to, changes this structure — and a schedule that misses the update either misallocates a real cost or reports on a structure that no longer matches how the business actually operates.
Set the fiscal year and cut-off date
Agree on the exact fiscal year the schedule will reflect and its cut-off date — typically your company's fiscal year-end, but the specific date matters because it's what every document's figures need to be measured against, including any invoices that arrive after year-end but relate to costs incurred before it.
Communicating this cut-off clearly to accounts payable and payroll, especially if source documents are being gathered from multiple departments, avoids a common source of confusion — an invoice booked in the wrong fiscal year, or a payroll period split incorrectly across the boundary.
Collect vendor invoices and payroll registers
Gather every vendor invoice and payroll register for the fiscal year, ideally pulling directly from your accounts-payable and payroll systems rather than reconstructing from memory or scattered email. Treating collection as a systematic pull against the general ledger's activity for the year — rather than a partial gathering based on which invoices happen to be easy to find — is what keeps the rest of the process from starting on an incomplete population.
Read and code each document to its pool
For each document, pull the amount, vendor, description and existing account coding, and assign it to the correct pool per your cost accounting policy — the same columns, the same category labels, regardless of how the vendor or payroll provider formatted the original. This is the step where automatic cost pool allocation does the most work if you're using it, and where a manual process needs the most discipline, since it's the easiest step to rush under a deadline.
Screen for unallowable costs
Review every coded document against your unallowable-cost policy — entertainment, alcohol, fines and penalties, and the other categories FAR 31.205 identifies as expressly unallowable. Flag and exclude anything that qualifies before it reaches a pool total, documenting the reasoning for each exclusion so the decision is defensible if questioned later.
Total each pool and each base
With every document coded and unallowable costs excluded, sum the figures into pool totals and base totals. This is the step where a manual spreadsheet is most prone to a simple arithmetic slip — a formula that doesn't capture a newly added row, a total that references the wrong range — worth a careful independent check before moving to the next step.
Reconcile pool and base totals to the general ledger
Compare every pool and base total against the corresponding general ledger account balances for the fiscal year. A schedule that doesn't tie to the books is one of the first things an auditor checks, and a gap found here — before submission — is far cheaper to resolve than one found during an actual audit.
Calculate the rates and compare to provisional
Divide each pool total by its base total to get the final indirect cost rate, then compare each rate against the provisional billing rate used during the year. A significant variance isn't necessarily a problem, but it's worth understanding and being ready to explain before it's submitted — a rate that moved because of a specific, documented cost driver is a much easier conversation than one nobody has looked at closely yet.
Assemble the supporting schedules
With every pool and base calculated and reconciled, compile the final submission-ready schedules — the summary of claimed rates, the detailed pool schedules, direct costs by contract, and whatever additional supporting detail your specific submission format requires.
A worked example, start to finish
A contractor with roughly $8M in annual revenue runs its fiscal year-end rate schedule preparation. The company maintains three pools — fringe, overhead and G&A — allocated over direct labor and total cost input bases respectively.
| Step | Outcome |
|---|---|
| Documents collected | 840 vendor invoices, 26 payroll registers |
| Documents coded | 97% coded automatically with high confidence; 24 flagged |
| Unallowable costs screened | 3 invoices excluded — entertainment and a late fee |
| GL reconciliation | 1 variance found — a December invoice booked in the wrong month |
The schedule goes to the outside CPA for final review two weeks ahead of the submission deadline, with every figure already traceable to its source document — leaving the CPA's time for reviewing judgment calls and unusual items rather than re-verifying routine ones from scratch.
A printable checklist
Pool structure and allocation bases confirmed against current policy
Fiscal year and cut-off date set and communicated
Every vendor invoice and payroll register collected, or explicitly marked missing
Every document coded to its pool with a documented rationale
Unallowable costs screened and excluded, with reasoning documented
Pool and base totals reconciled to the general ledger
Rates calculated and compared to provisional billing rates
Supporting schedules assembled and reviewed before submission
How much time each step actually takes
| Step | By hand | With automated reading |
|---|---|---|
| Coding 800+ invoices to pools | Several days | A few hours |
| Unallowable cost screening | 1–2 days | A few hours, reviewing flagged items |
| GL reconciliation | Half a day | 1–2 hours, since totals are already organized |
Common mistakes worth avoiding
Starting the coding pass before the full document population is collected
Coding against an incomplete set means recoding or missing documents later — collect first, then code the full year at once.
Assuming a vendor always codes to the same pool
The same vendor can bill costs that belong in different pools across the year — check each invoice's actual content, not just the vendor name.
Skipping the GL reconciliation step to save time
A schedule that doesn't tie to the books is one of the first things an auditor checks — skipping this step just moves the discovery to a worse moment.
Treating a flagged unallowable cost as optional to resolve
An unallowable cost left in a pool by oversight, rather than a documented judgment call, is exactly the kind of finding an audit is built to catch.
Doing this across several open fiscal years
It's common for a contractor to have more than one fiscal year's incurred cost submission open at once — a delayed prior-year submission alongside the current year's in preparation, or a DCAA audit reopening a year already submitted. The nine steps don't change per year — what changes is the number of times they need to be run in parallel, which is exactly where a manual process starts to strain and an automated reading step pays off fastest.
Doing this with software vs. by hand
Every step above works with nothing more than a spreadsheet and discipline — plenty of contractors run exactly this way. Where software like FlowParse's indirect cost rate documentation changes the equation is step 4, reading and coding each document, and step 5, screening for unallowable costs — the two steps that consume the most manual time and carry the most risk of a transcription or classification error, done the same way every fiscal year regardless of how many documents are involved.
If this is your first rate schedule ever
Start with step 1 even if it feels obvious — writing down the pool structure and allocation bases explicitly, ideally confirmed with a cost accounting advisor, is what everything downstream depends on. Run the first schedule against a fiscal year you can sanity-check carefully, and expect it to take noticeably longer than every subsequent one, since there's no established process or prior-year comparison yet.
Who this guide is for
Government contractor controllers and cost accountants building or refining an annual rate-schedule routine, outside CPA firms preparing incurred cost submissions for contractor clients, and contracts or compliance managers who want a repeatable process rather than starting from scratch every fiscal year.
A simple internal template
A minimal working template needs four things: a document log with vendor, amount and assigned pool for every invoice and payroll entry, a standardized figures tab with the same columns for every document, an unallowable-cost exclusion log with documented reasoning, and a final summary tab pulling from the standardized figures into pool and base totals. Nothing more elaborate is required to start — refinement comes with use, not up front.
When Cost Accounting Standards apply
Larger contracts and contractors above certain thresholds are subject to full or modified Cost Accounting Standards coverage, which adds specific requirements around consistency in how costs are estimated, accumulated and reported — those thresholds and the specific standards that apply are a determination worth confirming with your compliance advisor, since CAS applicability and its exact requirements are contract- and contractor-specific and can change with revised regulations.
Even for a contractor not subject to full CAS coverage, following the same discipline — consistent pool definitions, consistent allocation methodology, documented changes — makes both the rate schedule easier to defend and any future CAS applicability easier to demonstrate compliance with, should the contractor grow into coverage.
Handing this off to someone else
A rate-schedule process that lives entirely in one person's head is a risk the moment that person is unavailable ahead of a submission deadline. Writing the pool structure, the coding rules and the unallowable-cost policy down — even briefly — is what makes it possible for someone else to pick up the process without starting from zero.
What good documentation actually looks like
A rate schedule is only as defensible as the trail behind each figure in it. Good documentation for this process doesn't mean an elaborate write-up — it means three specific things kept together for every fiscal year: the original document each pool figure came from, a short note on any judgment call made (which pool a split invoice was assigned to, why a cost was treated as unallowable or allowable), and the date the schedule was actually completed relative to the fiscal year it covers.
Without that third piece, a schedule reviewed months or years later during an audit gives no way to tell whether a figure was actually current at the time or a placeholder that was never updated. A simple completion date on each year's schedule closes that gap at almost no cost.
| Kept with each fiscal year | Why it matters |
|---|---|
| Original document per pool figure | Lets any figure be traced back to its source without hunting through old accounts-payable folders |
| Notes on judgment calls | Preserves the reasoning behind a pool assignment or an allowability decision |
| Completion date vs. fiscal year covered | Distinguishes a genuinely current schedule from a stale placeholder |
Building this into an annual calendar
A rate-schedule process that only exists as a mental checklist tends to slip whenever the person who usually runs it is unavailable, or whenever a busier month pushes it a few weeks later than usual. Turning the nine steps above into an actual calendar entry — with realistic dates tied to your fiscal year-end and the submission deadline, based on the prior year's actual timing rather than an optimistic guess — makes the process something the team works toward rather than something that happens whenever there's time.
A useful version of this calendar notes, per step, how long it realistically took the prior year, so the collection and coding steps can start with enough runway rather than only noticing a schedule is behind once the submission deadline is uncomfortably close.
When a discrepancy doesn't resolve cleanly
Most flagged discrepancies turn out to be timing differences — an invoice booked a few days either side of the fiscal year-end, a payroll accrual using a slightly different cutoff. Occasionally one doesn't resolve that cleanly: a general ledger balance appears to be wrong, or a document genuinely can't be located within a reasonable window.
In that situation, the right move is to document the item clearly as an open issue with the reasoning for how it was ultimately handled, rather than either guessing at a resolution or delaying the entire submission indefinitely. A rate schedule with one honestly documented open item is more defensible, and more trustworthy under audit, than one silently adjusted to make an unresolved figure look settled.
A short glossary for this process
A few terms come up repeatedly through this guide and are worth defining precisely, since loose use of any of them is where a rate schedule quietly drifts from what it's actually supposed to represent.
| Term | What it specifically means here |
|---|---|
| Pool | A grouping of indirect costs that share a common allocation base |
| Base | The direct cost measure a pool is divided by to calculate a rate |
| Provisional rate | The billing rate agreed for use during the year, trued up at year-end |
| Unallowable cost | A cost expressly excluded from government billing under FAR 31.205 |
| Incurred cost submission | The annual filing reporting actual indirect rates for a fiscal year |
Precision on these terms matters most when handing the process to someone new — a cost accountant who inherits a rate-schedule routine with a shared, exact vocabulary spends far less time re-establishing what each step actually means than one working from a looser, informally understood version of the same nine steps.
A final quality check before submitting
Before a rate schedule is submitted, a short final pass catches most of what a rushed process misses. Confirm the pool structure matches what was set in step one — no pool silently dropped, none duplicated. Confirm every pool total ties to the general ledger and every base total does too. Confirm the unallowable-cost exclusions are documented with a clear rationale, since a reviewer will ask why each one was excluded.
This check takes a few hours and catches the kind of small, embarrassing error — a duplicated invoice, a stale total left over from a prior draft — that a careful process otherwise avoids but a rushed one under deadline pressure sometimes lets through. It's worth treating as a fixed step, not an optional one skipped when time is short, since time being short is exactly when these errors are most likely to occur.
Revisiting the process once a year
A rate-schedule routine that works well doesn't need touching every fiscal year, but it's worth a deliberate annual review rather than running on autopilot indefinitely — cost accounting policy occasionally shifts, a contractor's pool structure grows or consolidates as the business changes, and an unallowable-cost screen tuned three years ago may no longer reflect the current mix of vendors and cost categories. A short annual check against the nine steps and the checklist above is usually enough to catch drift before it becomes a real gap an auditor finds first.
This is also the natural moment to confirm the pool structure still matches what your cost accounting advisor recommends, since a structure that made sense for a smaller contract portfolio sometimes needs revisiting once the business has grown into a different size or contract mix than it had when the structure was first set.