What is software capitalization and why does it matter?
The accounting treatment for costs of developing software varies, but is often complex. This article provides a high level summary produced in partnership with technical accounting firm Principal Consulting Group (PCG) on how certain costs are accounted for during the project lifecycle - from planning through release and maintenance.
Every company seems to be a software company. From newspapers with software arms spinning up data visualizations to manufacturers building best in class internal tools, software is ubiquitous.
And yet despite being everywhere, determining how you should treat software development as an accountant continues to be complicated.
We wrote this guide to help demystify the world of software capitalization and help you determine how to best handle software development in your company.
Treating software development costs as an asset
Software capitalization is the process of treating the costs of developing software as an asset on your company's financial statements. As such, the recognition of the expenses spent developing the software – primarily payroll costs spent on developers – are delayed and spread out over the useful life of the software projects instead of being recognized upfront during the development.
Why capitalize software development costs?
The rules around software capitalization can feel murky. When does it make sense to begin capitalizing software? How should you capitalize software across different phases?
Most companies begin capitalizing software development expenses as they prepare for their first financial audits under U.S. generally accepted accounting principles (US GAAP), following guidance largely falling under ASC-350. Before then, depending on the company, the costs may not be material.
Companies must capitalize eligible R&D expenses in order to produce GAAP-compliant financial statements. Companies vary in the amount of their R&D spend depending on their business – anywhere from 1% to 20% of R&D expenses is common.
The good news about capitalizing software? Companies may benefit from the reduction in expenses that boosts EBITDA and other profitability metrics.
And the not so good news? Many business stakeholders don’t think about their business based on these GAAP adjustments — many leaders view their business instead on a cash basis. Investors may also allow for finance teams to back these adjustments out when presenting financial reporting (i.e., provide non-GAAP statements).
And it’s another complex accounting process that must be managed, with collaboration required between multiple departments. Software capitalization can slow down the month-end close and create even more work for already overworked accounting teams.
It can help to talk to an accounting expert or your auditor to determine what capitalization policy makes sense for your business based on your development style and life cycle. They’ll have a better idea of industry best practices and what makes sense for your business.
The software capitalization process
The software capitalization process is similar for both internal-use software and software to be sold or leased:
Software for internal use
The first category of software is internal-use software, or software that will not be externally marketed or leased. Examples of common internal-use software include accounting or CRM (customer relationship management) systems.
There are three development stages for internal-use software:
Preliminary Project (or pre-coding) stage
This is the conceptual stage. Companies determine the needed technology and select the best solution. In this stage, the costs are expensed. You will need to record expenses as they’re incurred during the preliminary project, or planning stage.
Application development (coding) stage
This is where software is capitalized, except for general or administrative costs related to the development. Capitalize costs related to:
However, not all costs are treated the same. Administrative or project management time should not be capitalized. The cost that is capitalized is typically “hands on keyboard” time.
Implementation (live) stage
Once the software is completed or ready for its intended use, the capitalization of costs stops. You will record any costs associated with the roll-out as expenses, including maintenance and user training.
Agile development for internal-use software
Unlike traditional linear (or “waterfall”) methods, agile development involves continuous iteration through sprints, resulting in individually developed and ever-change features. This dynamic approach may not align with the distinct project stages outlined above. Companies need to judiciously apply guidance based on the nature of the costs incurred, distinguishing between activities like coding (usually capitalized) and training (expensed as incurred).
Software to be sold, leased, or otherwise marketed
Software to be sold or leased is software developed for external users or marketed to the public. Costs associated with software development that will be sold, leased, or marketed to others are amortized and recorded as cost of sales. This is because the amortization of such costs is directly linked to the revenue recognized on the software product. Therefore, the expense incurred is charged to cost of sales (or a similar expense category), which is consistent with other non-software products sold or marketed to others.
There are three specific stages for software companies sell, lease, or market to external users:
Software development costs should be expensed as they are incurred until the point where the project has demonstrated technological feasibility.
Technologically feasible but not available for sale
A large portion of costs should be capitalized in this stage, including:
- Associated labor costs
However, you cannot capitalize upfront analysis, knowledge acquisition, maintenance costs, error, correction costs, or design work done to achieve an understanding of the product’s desired features.
Available for sale
The costs in this stage should be expensed as they are incurred.
Agile development for externally marketed software
When applying accounting guidance for externally marketed software, companies using an agile method typically delay capitalization. In contrast to linear development, agile processes often do not establish technological feasibility until much later in the development process.
Software capitalization rules under US GAAP and IFRS:
As software has become more prevalent with the increase in cloud computing, criteria and accounting standards surrounding software capitalization have been updated and clarified.
The costs after planning and design are capitalizable, but not ongoing maintenance. In general, the types of expenses that meet this criteria are:
- Purchase of computer software/software licenses
- Coding and testing
- Purchase of external materials
For sale, lease, or market
After technological feasibility is achieved and a realistic product is created, you can capitalize:
- Remaining development work for features and functionality
Download our software capitalization template
US GAAP vs IFRS
US GAAP (or GAAP) requires that all R&D is expensed, with specific exceptions such as capitalized software costs. IFRS, on the other hand, allows broader capitalization of development costs as long as certain criteria are met. This distinction extends to the types of costs that can be capitalized during the development phase, where IFRS permits a wider variety of costs to be capitalized compared to GAAP. This inherently leads to a more complex accounting framework for R&D under IFRS as compared to GAAP.
The complexity between the two extends beyond just R&D capitalization; it's embedded in their fundamental frameworks. GAAP operates on a more rules-based approach, providing detailed guidelines to follow in specific situations. Conversely, IFRS adopts a principles-based framework, encouraging the use of professional judgment in the interpretation and application of the standards
Managing the software capitalization process
Managing software capitalization can be a complicated process.
First, it’s important to define and build a process for tracking the projects that will be capitalized. Typically, accounting and engineering leaders will review the projects in a period – whether monthly, quarterly, or annually – and identify the projects that are capitalizable. This is often done by using the company’s issue tracking system (like Jira, Linear, Asana, or others) to both identify major projects and to use as evidence supporting the treatment.
Practically, it’s important to define what constitutes a project. It may be beneficial to set a threshold for the size of projects that will be capitalized such as to reduce immaterial projects and to not get lost tracking a high volume of small projects. As tracking and automation technology develops, over time it may become less time and cost intensive to capitalize on a more granular level. In all cases, it’s important to discuss with your auditor to make sure they are on board with your approach.
Once you have gathered a list of projects, teams then must identify a cost for each project by attributing an estimate of hours to each project and the associated payroll expenses for the relevant R&D employees. Note, this includes both cash and non-cash expenses, including stock-based compensation, and benefits (healthcare, taxes).
Practically there are multiple methods by which companies get to project costs.
- Top-Down Approach – companies with this approach look at the total cost and then carve out how much is capitalizable. Typically requiring they (1) pull the total compensation for a period, (2) apply a reasonable percentage of the total team effort against the capitalizable projects, and (3) calculate the project cost accordingly. This is most common for early or mid-stage companies going through their first audit.
- Bottoms-Up Approach – companies with this approach look at tickets to determine costs. Typically requiring they (1) identify the hours individual engineers spent on each project, (2) estimate the percentage of each project that is capitalizable, and (3) calculate the project cost accordingly. This is most common for late-stage growth companies. Companies might distribute this responsibility out to individual engineers or have an engineering manager review the data and ascertain the capitalizable amount accordingly.
Once the cost data has been gathered for each project, it’s time to develop a process to amortize the projects for their expected lifetime, review the schedule for impairments regularly, and to calculate and record the adjustment on a regular basis.
Example: Software capitalization for Lucy’s Lemonade Stand
This app allows customers to pre-order their lemonade, select flavor add-ons, and even schedule a delivery if they live within a certain radius. Developing this app requires Lucy to invest in software development, which can be capitalized.
Software Development Costs for Lucy's Lemonade App:
Preliminary Project Stage (Research and Planning): $500
Application Development Stage:
- Design of the user interface: $2,000
- Coding and testing: 4,000
- Data conversion: $1,000
Post-Implementation/Operational Stage (Maintenance and Training): $500
(Note: Costs incurred during the preliminary and post-implementation stages are expensed as incurred, but certain costs during the application development stage can be capitalized. In this example, the software is completed on February 28, 2023.)
Sample Journal Entries:
Initial Expenses (Preliminary Stage)
- Date: 01/01/2023 Debit: Research and Development Expense: $500 Credit: Cash: $500 Description: Expensed preliminary project stage costs for Lucy's Lemonade App.
Capitalization of Software Development Costs (Application Development Stage)
- Date: 01/31/2023 Debit: Software Under Development (Asset): $6,000 Credit: Cash: $6,000 Description: Capitalized costs related to the design, coding, testing, and data configuration of Lucy's Lemonade App.
- Date: 02/28/2023 Debit: Training and Maintenance Expense: $500 Credit: Cash: $500 Description: Expensed post-implementation operational costs for Lucy's Lemonade App.
Once the software is ready for its intended use (in our example, February 28, 2023), Lucy would then start to amortize the capitalized software cost over its useful life. If Lucy estimates the app's useful life to be 5 years, she would amortize the $6,000 over that period.
Amortization of Software
- Date: 12/31/2023 Debit: Amortization Expense: $1,000 Credit: Accumulated Amortization - Software: $1,000 Description: Amortization of Lucy's Lemonade App for the year 2023.
(Note: This amortization entry would be continued through the software’s useful life - until February 28, 2028.)
How Numeric can assist
Software capitalization adds yet another layer of complexity to a company’s close — requiring collaborating with engineering on ticket tagging or cost estimates and verifying the stage of software development.
Top teams developing software, like Wealthfront and Public.com, leverage Numeric to streamline the work of their monthly close to avoid the headache that software capitalization can be and ensure balance sheet accuracy. With Numeric, teams automate emails to key stakeholders across the business, outline dependencies in monthly close tasks, and easily report on their underlying GL data to surface insights related to software development costs and beyond.
As organizations rely more heavily on software for various internal processes or develop software for external use, accountants increasingly will need to be familiar with the nuances of software capitalization and the best application for their business.
It's crucial to use modern tools such as Numeric and follow best practices. By doing so, teams can greatly improve efficiency and accuracy in managing this critical and complex accounting treatment.