Capitalizing Software Implementation Costs Under GAAP

When UshaOm implemented a new ERP system, our implementation costs hit seven figures. The accounting treatment — what to capitalize versus expense — became a recurring argument between engineering and finance. Getting this wrong doesn't just affect your P&L; it can trigger audit findings.

Software implementation costs represent one of the largest and most confusing categories in software-related capitalization. When your organization deploys a new ERP system, implements a SaaS solution, or customizes enterprise software, the costs can reach seven or eight figures. Yet the accounting treatment varies dramatically depending on whether you're implementing cloud-based or on-premise software, whether the software is acquired or built, and how the implementation activities are classified.

This guide walks you through the specific rules for implementation cost capitalization, including the critical ASU 2018-15 guidance on cloud computing arrangements, the distinctions between SaaS and traditional software, and the practical challenge of segregating configuration costs (capitalizable) from service costs (expensed).

The Big Picture: Implementation Cost Categories

Every major software implementation involves multiple cost categories, and each receives different accounting treatment:

*Cloud configuration may be capitalized under ASU 2018-15 if it creates or enhances an intangible asset.

The confusion arises because "implementation" is an umbrella term that encompasses activities with different accounting treatments. A $200,000 implementation budget might split into:

• $40,000 vendor configuration (capitalized)
• $60,000 internal labor (expensed)
• $50,000 data migration (partially capitalized)
• $30,000 training (expensed)
• $20,000 hardware (capitalized)

Getting the split right is essential for accurate financial reporting.

Cloud Computing Arrangements: ASU 2018-15 Changed Everything

In December 2018, the FASB issued ASU 2018-15, which fundamentally changed how organizations account for implementation costs in cloud computing arrangements. Before this update, many organizations expensed all cloud implementation costs. The new standard requires capitalization of certain activities under specific circumstances.

What is a "Cloud Computing Arrangement"?

A cloud computing arrangement exists when a vendor hosts software and delivers it to you through the cloud. Common examples:

• Salesforce, NetSuite, Workday, SAP Cloud
• Microsoft Dynamics 365 (cloud version)
• Adobe Creative Cloud
• Slack, Microsoft Teams
• Netsuite, HubSpot, Zendesk
• Custom cloud platforms hosted by third parties

Key distinction: If the vendor hosts the software and you access it through a service agreement, it's a cloud computing arrangement. If you deploy the software on your own servers, it's not.

ASU 2018-15 Capitalization Rules

Under ASU 2018-15, configuration and customization costs of cloud computing arrangements are capitalized if and only if they create or enhance a non-financial asset that is controlled by your organization.

Key question: Does the configuration create an asset that you control, or does it simply modify the vendor's cloud environment?

Configuration Costs That Are Capitalized

• Setup configuration: Customizing the cloud system's data structures, workflows, and data mappings specifically for your business
• Custom integrations: Building or configuring connections between the cloud system and your other systems
• Custom reporting: Developing custom dashboards, reports, and analytics specific to your needs
• Data structure design: Designing custom fields, picklists, hierarchies, and taxonomies

These activities result in configurations that are specific to your organization and would take effort to reproduce if you changed vendors.

Service Costs That Are Expensed

• Implementation labor: Time spent by consultants or your team to analyze requirements, design solutions, and test configurations
• Training: End-user training, administrative training, and change management
• Project management: Time spent managing the implementation effort
• Vendor support: Vendor professional services time during the implementation
• Temporary support: Additional vendor support or consulting during the implementation phase

These are service costs—labor that generates value during the implementation period but doesn't create a lasting asset you own.

The Gray Area: Implementation Labor

This is where most organizations struggle. When your internal team configures the cloud system or a consultant builds custom configurations, is this capitalized or expensed?

The FASB Answer (ASC 350-40-25-7): Internal and external labor costs associated with developing or enhancing software are capitalized. But only if the work creates or enhances an intangible asset controlled by your organization.

Practical Application:

A. Your team configures Salesforce for your unique sales process:

• Activity: Creating custom fields, picklists, approval workflows
• Asset control: You own these configurations (Salesforce would preserve them if you switched vendors)
• Treatment: CAPITALIZED (the time spent is part of creating your custom asset)

B. Vendor consultant helps you understand Salesforce's capabilities:

• Activity: Training, coaching, explaining standard features
• Asset control: No permanent asset is created (this knowledge dissipates with consultant departure)
• Treatment: EXPENSED (this is professional services for configuration decisions)

C. Your team integrates Salesforce with your ERP system:

• Activity: Building API connections, custom middleware, data synchronization logic
• Asset control: You own the integration logic (it's your custom development)
• Treatment: CAPITALIZED (you've created a custom asset)

Practical ASU 2018-15 Implementation Example

Let's walk through a $500,000 Salesforce implementation:

Vendor Proposal Breakdown:

• Salesforce subscription (first year): $50,000
• Vendor configuration labor: 1,000 hours
• Data migration support: 200 hours
• Training delivery: 100 hours
• Project management: 150 hours

Blended vendor rate: $100/hour

Accounting Treatment:

Your Internal Team:

• Implementation project manager: 600 hours @ $75/hour = $45,000 (EXPENSED—project management)
• Business analyst designing requirements: 400 hours @ $75/hour = $30,000 (EXPENSED—service/consulting)
• IT staff configuring integrations: 200 hours @ $100/hour = $20,000 (CAPITALIZED—creating integration asset)
• IT staff testing and troubleshooting: 150 hours @ $100/hour = $15,000 (EXPENSED—testing/QA)
• Training coordinator and trainers: 100 hours @ $50/hour = $5,000 (EXPENSED—training)

Internal team total: $115,000

• Capitalized: $20,000
• Expensed: $95,000

Grand Total Capitalized: $70,000 + $20,000 = $90,000 Grand Total Expensed: $105,000 + $95,000 + $50,000 subscription = $250,000

The remaining $160,000 in implementation costs? These go into construction-in-progress or are capitalized as an intangible asset and amortized over the estimated useful life of the implementation (typically 3-7 years for cloud implementations).

On-Premise Software Implementation: Traditional Approach

On-premise implementations follow the traditional software capitalization rules under ASC 350-40, which are more straightforward (though still complex).

Software License Costs

When you purchase perpetual software licenses for on-premise deployment:

• License cost is CAPITALIZED as an intangible asset
• Amortized over the useful life (typically 3-7 years)
• This is straightforward—capitalize the license fee

Example:

• Purchase Oracle Enterprise Suite: $200,000
• Useful life: 5 years
• Annual amortization: $40,000

Implementation Costs for On-Premise Software

Implementation costs for on-premise software follow ASC 350-40's three-phase model we discussed earlier:

Phase 1: Preliminary (EXPENSED)

• Requirements gathering
• Vendor evaluation
• Implementation planning

Phase 2: Application Development (CAPITALIZED)

• Configuration and customization of the software
• Integration with existing systems
• Data migration and conversion
• Infrastructure setup (servers, databases, networks)

Phase 3: Post-Implementation (EXPENSED)

• Stabilization and bug fixes
• Training
• Parallel operations with legacy systems

On-Premise Implementation Example

A $600,000 SAP implementation costs:

Total capitalized: $150,000 (license) + $380,000 (implementation) = $530,000 Total expensed: $40,000 (Phase 1) + $10,000 (Phase 3) = $50,000

The $530,000 is recorded as a software asset and amortized over 5-7 years.

SaaS Subscription Accounting: The Lease Factor

Here's a complication many organizations miss: SaaS subscription costs are now governed by the lease accounting standard (ASC 842) in addition to ASU 2018-15. A SaaS subscription typically qualifies as a service contract or lease.

SaaS Subscriptions as Service Contracts

Most SaaS subscriptions are accounted for as service contracts (not leases) because the vendor retains significant operational control. In this case:

• Subscription fees are EXPENSED as incurred (typically monthly or annually)
• Implementation costs follow ASU 2018-15 (as discussed above)
• No capitalized asset for the subscription itself

Example:

• Annual Salesforce subscription: $50,000 per year → EXPENSED annually
• Implementation and configuration: $70,000 → CAPITALIZED
• Total Year 1 cost: $120,000 (but only $70,000 capitalized; $50,000 expensed)

SaaS Subscriptions as Leases (Rare)

In rare cases where you gain control over a specific instance of the cloud software, it may qualify as a lease under ASC 842. This requires:

• Identification of a specific asset (a dedicated instance or machine)
• Control over how the asset is used
• Control over who has access

If ASC 842 applies:

• The right-of-use asset is capitalized
• Lease liability is recorded
• Operating or financing lease treatment applies

This is increasingly rare as SaaS vendors typically don't allow customers the control necessary to trigger lease accounting.

Data Migration and Conversion Costs

Data migration costs are particularly complex because they can be service costs, capitalized implementation costs, or asset creation costs depending on the nature of the work.

Capitalized Data Migration

Migration work that is capitalized includes:

• Building data transformation logic: Creating ETL (extract-transform-load) processes specific to your system
• Custom mapping: Designing how data from your old system maps to the new system's structure
• Custom conversion tools: Building tools or scripts to convert and validate data

These create assets (data transformation processes) that would be transferred if you moved to another vendor.

Example:

• Building SQL scripts to migrate from Oracle to SAP: $30,000 → CAPITALIZED
• Designing data hierarchies and structures: $20,000 → CAPITALIZED

Expensed Data Migration

Migration work that is expensed includes:

• Data cleanup and validation: Reviewing and correcting data quality issues
• Reconciliation and testing: Comparing old and new system data
• Cutover activities: Running parallel systems, validating balances
• Vendor-managed data migration: Vendor services to perform the data movement

Example:

• Vendor data migration service: $25,000 → EXPENSED
• Your team data cleanup and validation: $15,000 → EXPENSED

Journal Entry Examples

Here's how different implementation costs appear in journal entries:

Cloud SaaS Implementation (ASU 2018-15)

DR: Construction in Progress (or Cloud Implementation Asset)    $70,000
DR: Implementation Expense (consulting, training, etc.)         $60,000
    CR: Cash / Accounts Payable                                           $130,000

When implementation is complete:
DR: Capitalized Cloud Implementation (or Software Asset)        $70,000
    CR: Construction in Progress                                         $70,000

Annual amortization (3-year useful life):
DR: Amortization Expense                                        $23,333
    CR: Accumulated Amortization - Cloud Software                       $23,333

On-Premise Software Implementation (ASC 350-40)

DR: Capitalized Software (License)                              $150,000
DR: Capitalized Software (Implementation)                       $380,000
DR: Implementation Expense (Phase 1)                            $40,000
DR: Implementation Expense (Phase 3)                            $10,000
    CR: Cash / Accounts Payable                                          $580,000

Annual amortization (5-year useful life):
DR: Amortization Expense ($530,000 / 5 years)                 $106,000
    CR: Accumulated Amortization - Software                              $106,000

Audit-Ready Documentation for Implementation Costs

Auditors will request:

1. Implementation cost breakdown by activity and classification (capitalized vs. expensed)
2. Vendor proposals and invoices supporting the costs
3. Time tracking for internal labor classified as capitalized
4. Phase transition documentation (when did Phase 1 end, Phase 2 begin, Phase 2 end, Phase 3 begin)
5. Description of capitalized assets and their characteristics
6. Useful life justification for amortization
7. ASU 2018-15 analysis (if cloud implementation) explaining why costs were capitalized or expensed

Organizations using tools like Glue have a significant advantage: Glue tracks engineering work at the code level, capturing:

• Which engineers worked on the implementation and when
• What specific configuration or integration work was performed
• Actual time spent on capitalizable activities vs. expensed activities
• Complete audit trail automatically updated as work progresses

This transforms implementation capitalization from a manual, spreadsheet-driven process into an automated, continuously-audited system.

Common Pitfalls to Avoid

1. Capitalizing all SaaS implementation costs: Remember: SaaS subscriptions are expensed annually. Only configuration creating permanent assets is capitalized.

2. Expensing all labor: Internal labor creating capitalized assets should be capitalized. Only service-oriented labor (consulting, training, project management) is expensed.

3. Failing to distinguish cloud vs. on-premise: ASU 2018-15 has different rules than ASC 350-40. Verify which applies before capitalizing.

4. Missing useful life reassessment: Cloud implementations may have shorter useful lives (3-5 years) than on-premise software (5-7 years). Document your assumptions.

5. Incomplete documentation: Without clear capitalization policies and time tracking, auditors will disallow capitalized amounts. Document phase transitions and cost classifications contemporaneously, not in retrospect.

The Path Forward

Implementation cost capitalization requires careful categorization of activities, understanding of whether cloud or on-premise rules apply, and rigorous documentation of which costs belong in which category.

The most sophisticated organizations move beyond manual spreadsheets. By leveraging systems like Glue that monitor actual engineering work and automatically classify activities as capitalization-relevant or expensed, you ensure accurate accounting, simplify audits, and eliminate the need for manual time tracking during implementations.

Your balance sheet accuracy—and your next audit—depends on getting implementation costs right.

---

Ready to simplify implementation cost capitalization? Glue automatically monitors and classifies engineering work during software implementations, creating the documented audit trail you need while eliminating manual time tracking. Connect with our accounting technology team to see how you can transform your implementation accounting.

---

Related Reading

• Capitalized Software GAAP: ASC 350-40 vs ASC 985-20 Compliance
• Capitalizing Software Development Costs: A CFO's Complete Guide
• Technical Debt: The Complete Guide for Engineering Leaders
• Software Productivity: What It Really Means and How to Measure It
• DORA Metrics: The Complete Guide for Engineering Leaders