Software Capitalization Journal Entries (with Examples)
The journal entries behind capitalized software — capitalizing the build, amortizing it over its useful life, and writing it off on retirement, each with a worked debit/credit example.
Capitalizing software changes where the cost lands, and that shows up as a specific set of journal entries. Three moments matter: when you capitalize the development cost, when you amortize it, and when you retire the asset. Here’s each, with the debit/credit entry and a worked example.
This is the bookkeeping side of what software capitalization is; for which costs qualify in the first place, see capitalize vs. expense.
1. Capitalizing development costs
When development reaches the point where costs qualify — the application-development stage for internal-use software under ASC 350-40 — you move those costs off the income statement and onto the balance sheet as an asset.
Say a team’s qualifying build costs (engineering salaries, contractor fees, tooling) total $480,000:
| Account | Debit | Credit |
|---|---|---|
| Capitalized software (asset) | $480,000 | |
| Cash / wages payable | $480,000 |
Instead of $480,000 of expense hitting this year’s income statement, you now hold a $480,000 asset that’s expensed gradually over time.
2. Amortizing the asset
Once the software is in service, its cost is amortized over its useful life. Straight-line over four years is $120,000 a year:
| Account | Debit | Credit |
|---|---|---|
| Amortization expense | $120,000 | |
| Accumulated amortization | $120,000 |
This entry repeats each period until the asset is fully amortized. Amortization expense hits the income statement; accumulated amortization is a contra-asset that reduces the software’s carrying value on the balance sheet.
3. Retiring or writing off
If the software is retired or replaced before it’s fully amortized, you remove the asset and its accumulated amortization and book the remainder as a loss. Say it’s scrapped after two years, with $240,000 still unamortized:
| Account | Debit | Credit |
|---|---|---|
| Accumulated amortization | $240,000 | |
| Loss on disposal | $240,000 | |
| Capitalized software (asset) | $480,000 |
The remaining book value becomes a one-time loss in the period you retire it. The same mechanic applies if an asset is impaired — written down before the end of its life.
Where the numbers come from
The hard part isn’t the entry — it’s knowing which development costs were capitalizable in the first place, and how much. On an Agile team, that means separating capitalizable feature work from expensed discovery, planning, and maintenance, across sprints and tickets. Quantify produces those numbers straight from your issue tracker, so the figures behind these entries trace back to the actual work — audit-ready, with no manual timesheets.
Frequently asked questions
What is the journal entry to capitalize software?
Debit a capitalized-software asset account and credit cash or wages payable for the qualifying development costs. That moves the cost from the income statement to the balance sheet.
How do you record amortization of capitalized software?
Debit amortization expense and credit accumulated amortization each period — typically the capitalized cost spread straight-line over the software’s useful life.
What happens in the books when capitalized software is retired?
Remove the asset and its accumulated amortization, and book any remaining unamortized cost as a loss on disposal in that period.
Is software capitalized or expensed?
It depends on the cost and the stage — qualifying application-development work is capitalized; research, planning, and maintenance are expensed. See capitalize vs. expense.
Capitalize software development costs in Jira — without the manual work
Quantify turns Jira activity into audit-ready software-capitalization data automatically — no manual timesheets.