You just spent $180,000 building custom software for your business. Your developer calls it an investment. Your bookkeeper calls it an expense. Your tax preparer says the answer is "both, on different returns." All three can be right at the same time — and picking the wrong treatment can overstate your profit by six figures, trigger an audit adjustment, or quietly breach a loan covenant.
The capitalize-versus-expense decision is one of the highest-stakes judgment calls in small-business accounting. Capitalize a cost and it lands on your balance sheet as an asset, then trickles onto your income statement as amortization over several years. Expense it and the full amount hits this year's profit immediately. Same cash out the door, completely different financial statements.
This guide walks through the rules that govern software development, SaaS subscriptions, and cloud infrastructure costs — ASC 350-40, ASC 985-20, and the cloud-computing guidance — plus where the tax rules diverge from your books.
Why This Decision Moves Your Numbers So Much
Capitalizing spreads cost recognition into the future. Expensing recognizes it now. That timing difference ripples through everything a reader of your statements cares about:
- Profit and EBITDA. Capitalizing $180,000 of development costs instead of expensing them adds $180,000 to this year's pre-tax profit (minus a small first-year amortization charge). EBITDA rises by nearly the full amount, because amortization is added back.
- Loan covenants. Many small-business credit agreements set minimum debt-service-coverage or profitability ratios. Aggressive capitalization can make a struggling borrower look compliant — until the bank's review catches it.
- Valuation. Buyers and investors normalize earnings for capitalized software. Inconsistent policies invite purchase-price haircuts during due diligence.
- Taxes. Your books and your tax return follow different rulebooks here. The gap between them creates deferred tax assets and liabilities you must track, and getting the tax side wrong means underpayment penalties.
None of this is a reason to fear the decision. It is a reason to make it deliberately, document it, and apply it consistently.
The Three Accounting Tracks for Software Costs
U.S. GAAP does not have one software rule. It has three, and the first step is figuring out which track your spending sits on.
Track 1: Internal-use software (ASC 350-40)
Software you build or buy to run your own business — an internal dashboard, a custom ordering system, automation scripts, an employee portal — falls under ASC 350-40. This is the track most small businesses live on. Even software you sell to customers as a hosted service (SaaS) is generally accounted for as internal-use software, because the customer never takes possession of the code.
ASC 350-40 divides every project into three stages, and the stage determines the treatment:
Stage 1 — Preliminary project stage: expense everything. Evaluating vendors, comparing build-versus-buy options, selecting technology, and feasibility work are all expensed as incurred. If you pay a consultant $15,000 to scope the project and recommend a platform, that $15,000 is an expense, full stop.
Stage 2 — Application development stage: capitalize qualifying costs. Once the preliminary stage is complete, management has committed to fund the project, and completion is probable, capitalization begins. Capitalizable costs include:
- Payroll and payroll-related costs for employees directly working on the project (proportioned to time spent)
- Fees paid to outside developers and contractors for design, coding, configuration, and testing
- Costs of software purchased specifically for the project
- Data conversion costs when the conversion is performed by software developed for the purpose
- Interest costs incurred while developing the software, if material
Training costs are always expensed, even when incurred during this stage. So are general administrative overhead and costs that cannot be tied to the project on a reasonable basis.
Stage 3 — Post-implementation and operation: expense everything again. Training, maintenance, minor bug fixes, and ongoing support after the software goes live are expensed. The exception: an upgrade or enhancement that adds functionality can restart capitalization for that new work, following the same three-stage analysis.
Capitalized internal-use software is amortized over its useful life — typically three to five years for most business applications — starting when the software is ready for its intended use.
Track 2: Software to be sold, leased, or marketed (ASC 985-20)
If you build software you sell as a product — a downloadable app, licensed on-premise software, a game — ASC 985-20 applies instead. Here the dividing line is a single milestone: technological feasibility. All costs before that point are research and development, expensed as incurred. Costs after feasibility but before general release are capitalized. Post-release maintenance is expensed.
In practice, many agile teams reach technological feasibility very late — sometimes with a working model that arrives days before release — so there is little left to capitalize. That is a legitimate outcome, not a failure to capitalize. Forcing costs into an asset when feasibility was never clearly established is one of the most common restatement triggers in software companies.
Track 3: Cloud computing arrangements (ASU 2018-15)
Cloud deals come in two flavors, and the accounting turns on one question: does the contract include a software license, or is it purely a service?
- Arrangement includes a license (you could take possession of the software and run it yourself): account for the license as internal-use software under ASC 350-40, and expense or capitalize the related costs under the three-stage model.
- Pure service contract (typical SaaS, hosting, and infrastructure arrangements): the subscription and usage fees are operating expenses. But the implementation costs — configuration, customization, integration work, data migration — are evaluated under ASC 350-40 by analogy. Application-development-stage implementation work is capitalized and amortized over the hosting term (including reasonably certain renewals). Preliminary-stage evaluation and post-implementation support are expensed.
This catches many businesses by surprise in both directions. Some expense a $60,000 ERP implementation that the rules say to capitalize. Others capitalize three years of SaaS subscription fees that are plainly operating expenses. The fees are almost never an asset; the one-time work to stand the system up often is.
What About Subscriptions and Cloud Infrastructure Bills?
Apply the framework above to the line items on a typical tech invoice:
| Cost | Usual treatment | Why |
|---|---|---|
| Monthly SaaS subscription (no license) | Expense | Service contract; you are paying for access, not an asset |
| AWS, Azure, or hosting usage fees | Expense | Pay-as-you-go service consumption |
| ERP or SaaS implementation and configuration | Often capitalized | Application-development-stage work under ASU 2018-15 |
| Custom integrations and API connectors you build | Often capitalized | Internal-use software development |
| Data migration scripting | Capitalize if software-driven | ASC 350-40 data conversion rule |
| Staff training on the new system | Expense | Training is always expensed |
| Ongoing support and maintenance plans | Expense | Post-implementation stage |
| New module that adds functionality a year later | Capitalize the new work | Enhancement restarts the stage analysis |
Two gray areas deserve extra care. First, configuration versus customization: toggling settings in a SaaS admin panel is rarely capitalizable, while writing custom code or complex integration scripts usually is. Document which hours were which. Second, the hosting term for amortization: amortize capitalized implementation costs over the period you expect to use the service, including renewals you are reasonably certain to take — not over some theoretical software life.
The 2025 Update That Changes the Stages
In September 2025, FASB issued ASU 2025-06, which retires the three-stage labels for internal-use software in favor of a single threshold: capitalize costs once management has committed to fund the project and completion is probable. The update is mandatory for annual periods beginning after December 15, 2027, with early adoption permitted.
For most small businesses, the practical effect is modest — the dividing line lands in roughly the same place the preliminary-versus-development boundary sits today — but the new standard signals that more agile, iterative development costs will qualify. If your team builds in sprints rather than waterfall phases, talk to your CPA about early-adopting. Until then, keep applying the three-stage model and keep the stage documentation your auditor expects.
Your Tax Return Plays by Different Rules
Here is where owners get burned: the GAAP treatment on your books and the tax treatment on your return are governed by entirely separate rulebooks, and they frequently disagree.
For tax years beginning after December 31, 2021, the Tax Cuts and Jobs Act required businesses to capitalize domestic research and experimental expenditures — explicitly including software development — and amortize them over five years (fifteen for foreign research). That turned "we spent $200,000 on developers" from a current deduction into a $20,000 first-year deduction with the rest dripping out over five years.
The One Big Beautiful Bill Act, signed in 2025, restored immediate expensing of domestic research and experimental costs, retroactive to tax years beginning in 2025, and clarified that software development counts. Small businesses generally have transition options for the unamortized 2022–2024 balances — accelerating the remainder or continuing to amortize it. Foreign research costs remain on the fifteen-year schedule.
The practical consequences:
- You will have book-tax differences. GAAP may require capitalizing implementation costs your tax return expenses immediately, or vice versa. Track both treatments side by side; your provision and your Schedule M-1 depend on it.
- State conformity varies. Not every state follows the federal restoration, so a cost expensed federally may still amortize for state purposes.
- Documentation serves two masters. Time tracking by project phase supports your GAAP stage analysis and your Section 41 research credit claim simultaneously. One good system feeds both.
Tax law moves fast enough that any guide like this one is a snapshot. Confirm the current-year rules with your preparer before filing — and never let the tax tail wag the GAAP dog. Your financial statements must follow GAAP regardless of what the tax return does.
Five Mistakes That Trigger Adjustments
- Capitalizing the evaluation phase. Vendor demos, RFPs, and "should we build or buy" consulting are preliminary-stage costs. Expensing them is not optional.
- Capitalizing training. Every standard is explicit: training is expensed, even during application development. Split it out of implementation invoices.
- Forgetting to stop. Capitalization ends when the software is ready for its intended use — not when the final invoice arrives. Post-go-live contractor hours are maintenance until a genuine enhancement begins.
- Capitalizing subscription fees. A three-year prepaid SaaS contract is a prepaid expense that amortizes as you consume the service, not a software asset. Do not run it through ASC 350-40.
- No time records. Capitalized payroll without contemporaneous time tracking by project and phase is the first thing an auditor or examiner disallows. Estimates reconstructed at year-end rarely survive scrutiny.
A Practical Capitalization Checklist
Before you book any software cost as an asset, answer these questions in writing and file the memo with the project records:
- Which track applies — internal use (350-40), software for sale (985-20), or a cloud service contract?
- Has the preliminary stage ended — is funding committed and completion probable?
- Is the software substantially complete and ready for use? If yes, capitalization has ended.
- Is this cost training, maintenance, data entry, or general overhead? If yes, expense it.
- Can you tie each capitalized dollar to a timesheet, invoice, or contractor statement of work?
- What amortization period reflects the expected useful life (or hosting term for implementation costs)?
- Have you recorded the tax treatment separately, including any book-tax difference?
A short memo answering these seven questions takes twenty minutes to write and can save weeks of argument with an auditor, a bank examiner, or the IRS.
Keep Your Software Spending Audit-Ready
Every invoice from your developers, your SaaS vendors, and your cloud provider is a classification decision waiting to happen. The businesses that get this right share one habit: they track software costs by project and phase as the money goes out, not when the CPA asks twelve months later. Tag implementation hours separately from support hours, split training out of vendor statements of work, and keep a running memo of which stage each project is in.
Clean records also make the book-tax split manageable. When your ledger already separates capitalized development from expensed subscriptions, preparing the return — and defending it — becomes a matter of pulling a report rather than reconstructing a year.
Beancount.io gives you plain-text accounting that keeps every one of those classifications transparent, version-controlled, and AI-ready — so your capitalization policy lives in your books, not in a spreadsheet no one can find. Get started for free and see why developers and finance professionals are switching to plain-text accounting.
