Accounting Reconciliation

How Do You Book a Capitalized Software Journal Entry?

If your company is unable to find off-the-shelf software that meets its needs, you may have employees or contractors building custom software. Purchased software is capitalized (made into an asset) and depreciated or amortized. You can also capitalize internally developed software as long as it is a true new development and not just bug fixes or ongoing maintenance work.

What software costs are capitalized?

Before we get into the details of software capitalization journal entries, let’s talk about the accounting treatment. Software that’s developed or acquired for internal use falls under ASC 350-40, part of a bigger standard on intangible assets. Software that’s developed with the intention of selling, leasing, or marketing it to external users falls under ASC 985.

For internally developed software, projects proceed in three general stages, and those stages determine whether costs are capitalized or expensed.

Project stage: At this stage, the various alternatives are being researched. Maybe an outside vendor has something that just needs a bit of customization, or maybe something needs to be built from the ground up. Costs at this stage include evaluating proposals from vendors and making the final selection. All costs for this stage are expensed as they are incurred. 

Application development stage: This is the coding stage, and also includes any testing before the software goes live. The total costs of this stage are capitalized as costs of the asset, and include these:

  • Programmer compensation
  • Payments to outside contractors and consultants
  • Travel for programmers and contractors
  • Interest expense to finance development
  • Testing
  • Direct and indirect overhead
  • Server installation 
  • Purchase of software 

This stage ends when testing is substantially complete, and the software is ready for use. 

Implementation stage: Once the software is live and being used, all costs for training and maintenance are expensed.

After the software goes live, the capitalized software development costs are amortized over the estimated useful life of the software. This is typically two to five years, and is generally done using the straight-line amortization method.

Depreciation and amortization are both methods of spreading the cost of long-lived assets over the years that they provide a benefit. Depreciation is used mostly for tangible assets while amortization is used for intangible assets. Like depreciation, amortization is a non-cash expense, so this gets backed out of your statement of cash flows. 

In today’s rapidly changing world, software may be abandoned before it’s fully amortized. Projects may also be discontinued before they are implemented. When that happens, any unamortized balance is expensed, and the capitalized asset plus the associated accumulated amortization are both removed from the balance sheet. 

But watch out  – upgrades and enhancements that add significant new functionality or features may trigger the application development stage to begin again. Those costs will be capitalized as a new asset.

Another thing to keep in mind is that you don’t have to follow the same rules for tax. But because there are tax credits for software R&D, you’ll make your tax accountants happy if you can keep those costs neatly segregated in your general ledger. 

What about software developed for external use?

The accounting standards draw a firm line between the accounting treatment for software developed for internal use and for software that will ultimately be sold, leased, or marketed to outside users. Like software that’s developed for internal use, the costs for external use software are split across three phases.

Pre-technological feasibility: This is the research and development phase, and under U.S. GAAP, R&D costs are expensed as they are incurred. They are not capitalized as they are under IFRS.

Technological feasibility: At this point, the research and development has been substantially completed, but the software is not yet ready for sale. From this point until the software is available for general release, all costs are capitalized. This can be a very gray area, and some companies essentially skip it.

Available for sale: When the software is ready for sale, all costs including maintenance, training, small upgrades, and customer support are expensed. At this point, amortization of any capitalized costs begins.

Like internally developed software, the capitalized cost journal entries are amortized using the straight-line method over the estimated useful life of the asset. And, like internally developed software, any salvage value or residual value at the end of that time period is generally zero.

What is the Capitalization Journal Entry for Software?

In this example, we’re assuming that the only costs we have to capitalize are the costs of labor, which come from outside contractors and engineers on staff. 

The trickiest part of the capitalized software journal entry is the data gathering. Getting the data from contractors is easy – ask them to invoice you and segregate development work from bug fixes and ongoing maintenance. As for getting data from your employees’ work – some companies choose to have engineers track by hour what they’re working on. Other companies may meet with engineering management quarterly or monthly and ask for estimates by employee. Some companies get savvy and get their data from the data the engineers already use, perhaps from “story points” if the team engages in “Agile” development. Now apply weighted (employer tax + benefits) salary rates to the engineer’s development time.

The details:

Journal: Capitalized Software

Frequency: Each reporting period (i.e. monthly)

FloQast folder location: ‘Fixed Assets’ is where software sits, and so can capitalized software. Just make sure engineer salary information is still available to any general ledger accountant or others who would otherwise need this information.

The dr.’s and cr.’s

Date Account Name DR CR
6/30/20 Internally developed software asset – Project XYZ $42,375
Internally developed software asset – Project ABC $15,000
Payroll accrual/clearing $57,375

                  Memo: To capitalize software internally developed during June 2020

Let’s assume the estimated useful life of this asset is three years, and that the implementation stage also began in June. Here’s the accounting entry to record the amortization expense:

Date Account Name DR CR
6/30/20 Amortization expense $1,584.00
Accumulated amortization, internally developed software $1,584.00

                  Memo: To record June 2020 amortization of internally developed software asset

What else do I need to know?

  • Capitalizing software does take a lot of time to calculate and document, but there are real benefits to the company’s bottom line. Salary expenses that would have otherwise been an immediate hit to net income can now be spread out over time, thanks to amortization. This makes earnings less volatile. 
  • If the company is an income tax payer (profitable), there is an R&D credit from the IRS. There are also new payroll tax credits for companies that are relatively young and don’t have gross receipts over a certain threshold. Your journal entries and underlying documentation will help your tax preparer make a claim for this real cash back.


  • Keep a running list of additions and disposals by project
  • Roll forward your net asset balance: Additions – amortization – software decommissioned = new net asset balance

Common pitfalls

  • Not crediting a contra expense account: Yes, we’re removing salary expense from your income statement. But remember you’ll always want to have salaries expense as a debit to wage expense at gross in your trial balance. Use a “contra” expense called “development” to make those credits (reductions) to expense.
  • Not capitalizing assets by the “product” or “project.” You may want to add internally developed software assets to your fixed asset register in chunks like “all the software we developed during June 2020.” But there may be different software projects mixed up in there. If a project were ever decommissioned, you will need to dispose of this asset. Make sure your data straight from the beginning can specify a “project” by creating separate asset accounts.
  • Not enough documentation! Auditors reviewing GAAP financial statements or the IRS reviewing R&D tax credits may disallow the capitalization entry if there isn’t sufficient documentation. Have your engineering management create a quarterly “narrative” in common language of what exactly was actually built that period. And, make sure as accountants we have documentation to allow an auditor to trace from an engineer’s time straight through to the journal entry!

How auditors audit

  • AUDIT READINESS is key! Auditors will ask for your fixed asset register. Then they’ll ask for the invoices, because this is how certified public accountants are taught to audit. But there aren’t invoices for employee-developed software! So you’ll provide them with the “narrative” of what was built for a general understanding, the underlying details like engineer’s hours coded to projects, and a salary listing for recalculation.