Explore comprehensive guidelines for internal-use software accounting, covering the three critical stages—preliminary project stage, application development, and post-implementation. Learn when to capitalize costs, when to expense them, and how to handle subsequent amortization. Includes practical illustrations, best practices, pitfalls, and a quiz.
Internal-use software (IUS) plays a pivotal role in modern business operations, enabling companies to streamline processes, enhance customer experiences, and maintain robust data management practices. Due to its growing significance, understanding the accounting treatment of internal-use software under U.S. GAAP is critical for financial professionals. In this section, we delve into authoritative guidance, highlight the different project stages, discuss capitalization rules, explore amortization approaches, and examine common pitfalls. We will also illustrate these concepts with practical examples and diagrams, further equipping you to apply them in real-world scenarios.
In the context of U.S. GAAP, internal-use software refers to software acquired, developed, or modified solely to meet the needs of an entity’s internal operations. This contrasts with software intended for sale, lease, or licensing to external parties. The Financial Accounting Standards Board (FASB) provides guidance under Accounting Standards Codification (ASC) 350-40, “Internal-Use Software,” which governs the capitalization and subsequent measurement of software costs.
Key points regarding the scope:
• Internal-use software is acquired or developed to meet an entity’s specific internal needs.
• There is no substantive plan to market the software externally.
• The software’s functionality primarily supports internal processes, data management, or service delivery within the organization.
ASC 350-40 (“Intangibles—Goodwill and Other—Internal-Use Software”) outlines the general framework for recognizing and measuring costs incurred in developing or acquiring software for internal use. The standard provides explicit guidelines to determine:
• Which costs should be capitalized.
• Which costs should be expensed.
• The timing of capitalization relative to the various stages of development.
• The useful life of the software and the appropriate methods of amortization.
In practice, these rules ensure consistency and comparability of software-related accounting, enabling stakeholders to assess the return on IT investments and evaluate an entity’s financial health more accurately.
ASC 350-40 divides the internal-use software lifecycle into three primary stages. Correctly distinguishing among these stages is essential for accurate financial reporting and compliance:
Below is a mermaid diagram illustrating these stages:
flowchart LR
A("Preliminary Project Stage") --> B("Application Development Stage")
B("Application Development Stage") --> C("Post-Implementation Stage")
Each stage entails specific accounting treatment, predominantly distinguishing between activities where costs must be expensed and activities where costs can be capitalized.
During the preliminary project stage, management typically explores technical alternatives, determines project feasibility, and refines project objectives. Activities might include:
• Evaluating vendor proposals.
• Conducting conceptual formulation and defining system needs.
• Selecting hardware or software vendors.
• Drafting initial designs and architectural concepts.
All costs incurred during the preliminary project stage are expensed as incurred. At this point, there is no firm commitment to develop the software, and many of these costs relate to feasibility studies, research, or brainstorming. The principle here is akin to R&D expenses, which are generally expensed until technological feasibility or a clear plan for development has been established.
The application development stage begins once the decision is made to proceed with software development or purchase. Typically, the entity has decided on specific functional components, and the development or customization of software has commenced. This stage covers activities such as:
• Coding, software configuration, and integration.
• Installing hardware and software necessary for development.
• Testing software modules and functionalities (prior to acceptance testing).
• Designing software interfaces and specifying coding structures.
During the application development stage, certain direct and incremental costs associated with coding, configuration, and testing (before the software is substantially complete) are capitalized. This includes costs for employees directly involved in the internal-use software project (e.g., salaries and wages of software developers) related to the programming or coding of the software. It also encompasses third-party consulting fees if external programmers or software engineers are contracted to build or customize the product.
However, overhead-type costs—for instance, general administrative or overhead employee costs—are typically not capitalized unless they are directly attributable to the software development project. Additionally, training costs for staff to use the new software are expensed. Only the specific costs that add future economic value to the software under development are to be capitalized.
The final stage begins once the software is ready for its intended use—this typically coincides with substantial completion and user acceptance. Subsequent costs in the post-implementation stage generally relate to:
• Day-to-day software maintenance.
• Routine repairs to keep the software operational.
• User support and troubleshooting.
• Minor or cosmetic updates that do not add new functionality.
All such maintenance and support costs are expensed as incurred. Only if additional development or major upgrades substantially enhance the software’s existing functionality or significantly improve performance can costs be capitalized again under the application development cost guidance.
The guiding principle is to capitalize expenditures that directly enhance the future economic benefit of internal-use software. The general considerations include:
• Direct Costs: For internal software developers, direct costs include salaries, wages, and payroll taxes for the hours spent actively coding or configuring the software. If an entity has a robust time-tracking mechanism, it can allocate a proportionate share of staff costs to the project for capitalization (only for the period covering the application development stage).
• Third-Party Costs: If a company pays external vendors or consultants to develop the software, these costs can be capitalized, provided they occur during the application development stage and directly contribute to the creation or enhancement of internally used software.
• General and Administrative (G&A) Costs: Typically not capitalizable unless they are directly associated with software development activities.
• Training and Data Conversion: Excluded from capitalization and expensed as incurred because they do not directly result in new or enhanced software functionality.
• Indirect Costs: Indirect overhead that cannot be directly tied to the development effort is expensed.
Capitalized costs should be recorded as an asset on the balance sheet in the “Intangible Assets” or “Property, Plant, and Equipment” section, depending on the entity’s accounting policies and the nature of expenditures for intangible assets. It is essential to maintain clear documentation and time allocation records to ensure only eligible costs go into capitalization.
Once the software is ready for its intended use—i.e., when it has passed acceptance testing and is placed into service—capitalized costs for internal-use software are amortized over its estimated useful life.
• The amortization period typically begins when the software is fully operational and performing as intended.
• The useful life is usually determined by considering how long the software is expected to provide value to the entity, its anticipated upgrades or obsolescence, and the pace of technological change in the industry.
In practice, many companies select an estimated useful life ranging from three to seven years, depending on the nature of the software and the industry’s pace of innovation.
Under U.S. GAAP, the straight-line method is most commonly used to amortize internal-use software. Straight-line amortization allocates the capitalized cost evenly across the chosen life (e.g., if a software asset costing $500,000 is amortized over five years, the amortization expense is $100,000 per year).
Other methods (e.g., sum-of-the-years’-digits or units-of-production) can be used if they better reflect the pattern in which the software’s economic benefits are consumed. However, simplicity and consistency often drive entities to adopt straight-line amortization.
In formulaic form, if C is the capitalized cost and n is the estimated useful life in years:
Amortization\_expense\_per\_year = \\(\frac{C}{n}\\)
Depending on whether an accelerating pattern of benefit is clearly established, a method alternative to straight-line might be justified.
Internal-use software is subject to impairment testing under the same general framework that applies to other long-lived assets (ASC 360). Indicators for impairment may include significant changes in technology, usage, or economic conditions. If the carrying amount of the internal-use software exceeds its fair value and is not recoverable, an impairment loss should be recognized.
Though post-implementation costs are generally expensed, companies must identify if certain post-implementation costs actually meet the criteria for capitalization of software enhancements. If the upgrade or update:
then those costs might be capitalized under the application development cost guidance. It is critical to maintain thorough documentation that clearly distinguishes routine maintenance (expensed) from significant enhancements (capitalized).
A growing area of confusion in practice involves cloud hosting or Software-as-a-Service (SaaS) arrangements. In these arrangements, the entity does not typically own the software (i.e., it’s not truly “internal-use software”), but rather pays a subscription fee to access and use the software. Generally, subscription fees are expensed as incurred unless the arrangement meets certain criteria that would allow capitalizing implementation costs.
ASC 350-40 was updated to address implementation costs in cloud computing arrangements, aligning their treatment with that of internal-use software only if specific conditions are met (e.g., the arrangement is or contains a software license). Companies must carefully analyze whether a contract conveys a right to control or license software or is purely a service.
While IFRS does not have a specific standard explicitly dedicated to internal-use software—IFRS typically analyzes such costs under IAS 38 (Intangible Assets)—the principles are broadly consistent. IFRS also requires that pre-development expenditures be expensed until the software is considered feasible for development. However, differences in specific terminology and detail often exist, and IFRS can allow more judgment in certain areas. U.S. entities that are subject to IFRS reporting in foreign jurisdictions should carefully assess these distinctions.
Omega Co. decided to build an in-house customer relationship management (CRM) system rather than purchasing an off-the-shelf solution. Below is the breakdown of costs incurred during the project timeline:
• Preliminary Project Stage:
– Conceptual studies and vendor evaluations: $50,000
– Creation of the business requirements document: $10,000
• Application Development Stage:
– In-house developers’ salaries during coding: $180,000
– Consultant fees for modules integration: $70,000
– Quality assurance testing prior to acceptance: $50,000
– Data conversion from an older system: $30,000
• Post-Implementation Stage:
– Maintenance updates for minor bugs: $5,000/month
– Customer service staff training: $25,000
Based on ASC 350-40:
At the end of the development stage, Omega Co. capitalizes $300,000 of software costs. Assuming they place the software into service on January 1 of the following year with an estimated useful life of 5 years, Omega Co. records $60,000 in amortization expense annually ($300,000 / 5 years). Maintenance costs and other post-implementation fees remain on the income statement as expenses.
Below is a concise table summarizing which types of costs are capitalized vs. expensed in each stage:
| Development Stage | Example of Costs | Treatment |
|---|---|---|
| Preliminary Project Stage | Feasibility studies, vendor evaluation | Expense |
| Application Development Stage | Coding, testing (prior to acceptance), direct consulting | Capitalize |
| Application Development Stage | Data conversion, general overhead | Expense |
| Post-Implementation/Operation | Maintenance, training, user support | Expense |
| Post-Implementation/Operation | Major upgrades adding new functionality | Potential Capitalize (if criteria met) |
Below are resources for additional guidance and deeper study on internal-use software and related intangible asset accounting: