Capex vs Opex Requisition Classifier & Justification Capturer

The problem this kills

A requisition lands for a "laptop refresh." Is that capex or opex? Depends on the dollar threshold, the asset class, and the useful life - rules that live in a policy PDF nobody reads. So requesters guess. Capital purchases show up with no business case, no project code, no payback math. Routine expenses get dressed up as "capital projects" to dodge a department budget. And finance is left untangling it at month-end, re-coding things by hand and chasing people for the justification they should have captured up front.

The result: misclassified spend, GL accounts that don't reconcile, capitalization policy applied inconsistently, and an audit trail that's really just a pile of emails. Worse, a "project" quietly blows past its approved capital limit because three separate requisitions all charged the same project code and nobody was watching the running total.

This tool moves the decision to the front door. Every request gets classified by your rules the moment it's submitted, capex requests can't move forward without the business case they require, and finance signs off before a single GL or project code is committed.

What you'll build

A small internal web app, just for your team, that:

• Lets a requester submit a purchase request - item, amount, useful life, asset class, department.
• Reads your capitalization policy (thresholds and asset-class rules) and proposes capex or opex, showing the exact rule it applied so the call is transparent, not a black box.
• For anything classified capex, collects the required justification - project code, business case, expected ROI / payback - and requires an attachment for the business case.
• Flags "componentized" requests - a bundle that should probably be split into separate capital items - so they get reviewed, not waved through.
• Routes each request to the right approval flow: opex one way, capex (with its business case) another.
• Gives finance a screen to review, confirm, or override the classification before anything is committed.
• On approval, commits the requisition with GL / project tagging that matches your chart of accounts.
• Warns when a capex request reuses a project code already at its approved limit, so you don't blow a capital budget by accident.
• Dedupes on requisition ID so the same request can't be processed twice.
• Exports a CSV grouped by treatment (capex vs opex) ready for your finance system, plus a full audit log.

What's inside the Implementation Plan

The plan is a single markdown file you paste into Claude Code (a free AI coding agent). It walks the agent through building the whole tool, step by step, each step ending with a ready-to-paste prompt.

The most important part: the plan opens by interviewing you about your business. Before it writes a single line, the agent asks how requisitions reach you today, what your capitalization policy actually says (thresholds, asset classes, useful-life rules), the real field names and code conventions in your data, your typical and peak volumes, your exact capex justification requirements and approval routing, and your messy edge cases (mixed bundles, leases, software, project codes near their limit). It reads a short tailored spec back to you, you confirm it, and only then does it build - so you get a classifier shaped to your policy, not a generic template you have to bend to fit.

Inside you'll find:

• The discovery interview and how the agent turns your answers into the data model and the classification rules.
• The full build: database, login, the submission form, the configurable rule engine that proposes capex/opex, the capex justification capture with attachments, the finance review/override gate, GL/project tagging, and the grouped CSV export.
• The componentized-request flag, the project-limit warning, and the duplicate guard.
• Verification steps so you can prove it works, and the CSV-import/export fallback so it's fully usable even before you connect it to your ERP.

The governance it includes (this is the point)

This isn't a toy. The plan builds in the controls a procurement and finance team actually needs:

• Login so only your team can see or touch anything.
• Row-level security so people only see the requisitions and policy that belong to your organization.
• A complete audit trail - every submission, classification, override, justification, approval, and commit is logged with who and when.
• A hard human-in-the-loop gate - the AI proposes a classification and drafts the routing, but finance must confirm the capex/opex call and approve the capex business case before the requisition is ever committed and a GL/project code is assigned. Nothing auto-commits.
• Duplicate guards so the same requisition ID can't be processed twice, plus a warning when a project code is already at its approved limit.

Who it's for

Procurement and finance staff who keep getting capex requests with no business case, opex requests dressed up as capital, and month-ends spent re-coding spend by hand. It's for the buyer, the AP/finance analyst, the controller, and the ops/BPM person who wants a real, auditable intake tool that applies the capitalization policy consistently - without hiring a developer or buying a heavyweight procurement suite. You don't need to write code. You need your policy sheet, your project-code list, and an afternoon.

You've got this - paste the first prompt and let the agent interview you.