Project & Client Cost Allocator: Cost Every Project Accurately
Import expenses and card charges, let AI tag direct costs and split shared ones by your rules, flag anything unallocated, and mark billable vs non-billable — then a human approves before it posts to project ledgers or billing.
An internal web tool where you import expenses, AI tags direct costs to projects and splits shared costs by your rules, flags unallocated items, marks billable vs non-billable, your project accountant reviews and approves the proposed allocations, and you export a project-cost ledger plus a billable-vs-non-billable summary.
Before you start
- A Supabase account (free)
- A Vercel account (free)
- Exports you already have: an expenses/card-charges CSV, a project/client list, and your allocation rules for shared costs
- How you split shared costs (percentages, or a driver like headcount or hours)
- Claude Code or any AI coding agent
The problem this kills
Every expense your firm spends belongs to a project — or it should. Some are easy: a contractor's flight booked for the Acme rebrand is obviously an Acme cost. But a huge slice of spend is shared — the team Figma seats, the cloud bill, the office rent, the project-manager's time — and somebody has to decide how much of that lands on each client. Get it wrong and your project margins are fiction: a job that looks profitable is quietly bleeding, and the one you thought was thin is actually your best.
So it gets done by hand, in a spreadsheet, at month-end, under pressure. A card charge gets tagged to the wrong project. A shared subscription never gets split at all and just sits in overhead. A billable expense gets buried and never invoiced to the client — pure lost revenue. The same charge gets pulled in twice from two exports and double-counts. And when a partner asks "is the Globex project actually making money?", the honest answer is "give me a day to rebuild the spreadsheet."
You don't need a six-figure professional-services automation suite to fix this. You can build the allocator yourself, this weekend.
What you'll build
An internal web tool your finance and ops team logs into. You import the expenses and card charges you already export, plus your project/client list. The tool proposes an allocation for every expense: direct costs get tagged to one project, and shared costs get split across projects by your rules — a fixed percentage, or a driver like hours logged, headcount, or revenue. It marks each line billable or non-billable, and it loudly flags anything it couldn't allocate so nothing slips into the void.
Your project accountant works the review screen — confirming the easy direct tags, scrutinizing the split/shared items where the judgment lives, fixing anything mis-tagged — and approves. Only on approval does anything post. Then you click once to export a project-cost ledger in the exact columns your accounting or billing system wants, plus a billable-vs-non-billable summary that finally tells you, per project, what's reclaimable from the client and what's on you. It handles the real-world mess too: partial splits, expenses spanning multiple projects, and a clean duplicate guard on expense ID.
What's inside the Implementation Plan
The downloadable plan is a single markdown file you paste into an AI coding agent. It opens by interviewing you about your own cost process — how you tag expenses today, your project and client codes, the exact fields in your expense export, how you split each kind of shared cost, what counts as billable, and your messiest edge cases — and then it reads a short spec back for your thumbs-up before it builds a thing. That's the difference between a tool shaped to your projects and a generic template you have to fight.
From there it walks the agent through the data model (projects, expenses, allocation rules, and allocation lines), the importers, the duplicate guard on expense ID, the direct-tagging and rule-based split engine, the billable flagging, the unallocated catch-all, the review-and-approve screen, and the final exports. Every step ends with a ready-to-copy prompt. There's a full "No API yet?" path: import from CSV, export a clean project-cost ledger CSV, and you never have to touch your accounting system's API to ship.
The governance it includes (this is the point)
Cost allocation feeds billing and margin reporting — the controls are the product. The plan builds them in: a login so only your team can use it; row-level security so each organization only ever sees its own projects and spend; a complete audit trail of who allocated, edited, approved, and exported, and when; a hard human-approval gate so no allocation posts to a project ledger or to billing until your accountant signs off; and a duplicate guard on expense ID so the same charge can't be allocated twice. Shared-cost splits — the judgment calls — physically cannot be exported until a person reviews and approves them. That's the audit story your controller and your clients' auditors want.
Who it's for
Project accountants, finance leads, and operations managers at agencies, consultancies, and professional-services firms who have to cost projects accurately and bill clients fairly. If you can explain to a new hire how a shared subscription gets spread across clients and what makes an expense billable, you can build this — no developer required.
You've got this — open the plan, paste the first prompt, answer a few questions about how your project costing actually runs, and you'll watch your first batch of expenses allocate itself.