# 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](/software-capitalization/what-is-software-capitalization); for which costs qualify in the first place, see [capitalize vs. expense](/software-capitalization/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](/software-capitalization/glossary/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](/software-capitalization/economic-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](/software-capitalization/agile). [Quantify](/software-capex) 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.

[Talk to us about capex](https://www.quantifyhq.com/contact?utm_campaign=capex)