The Board Wants to Know: Are You Capitalizing Correctly?
Let's be honest. Your finance team asks about capitalizing dev costs every quarter. You're tracking time in spreadsheets that nobody trusts. Here's what actually matters.
What is Software Capitalization? (The Actual Answer)
Not the accounting textbook version—what you really need to know
Here's the deal: Software capitalization is when you treat development costs as assets instead of expenses. Sounds simple? It's not. The rules are a maze, and getting it wrong means awkward conversations with auditors and potentially restating financials.
I've seen CTOs scramble before board meetings, trying to explain why 40% of engineering costs were expensed when competitors capitalize 60%. The CFO is asking questions you can't answer. Your developers hate tracking time. Everyone's guessing.
The Rules That Actually Matter:
• Internal software? Capitalize during application development. Not planning. Not maintenance. Just the actual building part.
• SaaS product? After "technological feasibility" (whatever that means for your agile process).
• Cloud implementation? ASC 350-40 says capitalize, but only certain costs. Good luck figuring out which ones.
• Agile development? Yeah, the rules were written for waterfall. You'll need to get creative.
Reality Check: Useful Life of Software
Your auditor will ask. Here's what companies actually use:
• Internal tools: 3-5 years (they know you'll rebuild it)
• Customer-facing products: 2-3 years (market moves fast)
• Enterprise software: 5-7 years (optimistic, but defensible)
• Mobile apps: 2 years max (be realistic)
Software Development Costs: The Capitalize vs Expense Fight
Your finance team needs this list. Print it out. Tape it to the wall.
What You CAN Capitalize (Finance Will Love You):
Developer Salaries During Builds
That senior engineer who spent 3 months on your new feature? Their salary for those months is capitalizable. But only the time actually coding, not the meetings about coding.
Contractor and Consultant Fees
That $200/hour consultant building your payment system? Capitalize it. The one teaching your team how to build it? Expense it.
Software Licenses for Development
GitHub Enterprise, AWS credits used for the product, that expensive IDE license—if it's directly used for building capitalizable software, it counts.
Testing and Quality Assurance
QA engineer salaries during testing phase? Capitalize. Automated testing tool licenses? Capitalize. Finding bugs after release? That's maintenance—expense it.
What You MUST Expense (Stop Trying):
Planning and Research
Those 3-week discovery sprints? The architecture debates? The vendor selection process that took forever? All expenses. Yes, even though they're necessary.
Maintenance and Bug Fixes
The moment you ship, it's all expenses. That hotfix you pushed at 2 AM? Expense. The security patch? Expense. Minor enhancements? Still expense.
Training and Documentation
Your team learning React? Expense. Writing user docs? Expense. Creating internal wikis? Expense. Yes, even if it's for a capitalizable project.
General Overhead
Your manager's salary, the office rent allocation, the Friday beer—none of it counts. Don't even try to allocate "overhead." Auditors hate that.
Amortization of Software: The Part Nobody Explains Well
You capitalized $500k. Now what? Here's how to not screw up the amortization.
The Amortization Playbook:
Straight-Line (90% of you): Take your capitalized amount, divide by useful life. Done. $600k over 3 years = $200k/year expense. Your CFO will appreciate the predictability.
Revenue-Based (SaaS products): Match expense to revenue. Sounds smart, gets complicated fast. Only do this if your auditor insists.
When to start: The day it goes live. Not when you think it's done. Not when QA signs off. When actual users can actually use it.
The Impairment Test (The Thing That Bites You):
Every year, you need to ask: "Is this software still worth what we say it is?" If not, you write it down. This hits when:
• You sunset the product (happens more than you think)
• A competitor makes your feature obsolete
• That "game-changing" platform pivot means abandoning old code
• Usage drops off a cliff
Pro tip: Tell finance early if something's getting killed. Surprise write-downs make CFOs very unhappy.
Real Software Capitalization Scenarios
Actual situations you'll face (not textbook examples)
Scenario: "We're Building a Customer Portal"
Timeline: 6 months, 5 developers, agile sprints
• Sprint 1-2 (Research & Design): $80k - EXPENSE (it's all planning)
• Sprint 3-8 (Core Development): $480k - CAPITALIZE (actual building)
• Sprint 9-10 (Testing & Deploy): $160k - CAPITALIZE (still pre-launch)
• Post-launch fixes: $40k/month - EXPENSE (it's maintenance now)
Bottom line: $640k capitalized, amortized over 3 years = $213k/year
What finance sees: Lower expenses this year, predictable amortization going forward
Scenario: "AI Feature for Our SaaS"
The twist: Half research, half development
• ML research & experiments: $200k - EXPENSE (it's R&D)
• Building the production model: $300k - CAPITALIZE (now it's real)
• API integration: $100k - CAPITALIZE (product feature)
• Model retraining monthly: $20k/mo - EXPENSE (ongoing operations)
Bottom line: $400k capitalized, but watch out—AI features depreciate fast
Auditor question incoming: "How did you determine technological feasibility for AI?" Have an answer ready.
Scenario: "Major Refactor of Legacy System"
The question: Is refactoring capitalizable? (Usually no, but...)
• Refactoring for performance: $150k - EXPENSE (it's maintenance)
• Adding new capabilities: $200k - CAPITALIZE (new functionality)
• Migration to new platform: $250k - CAPITALIZE (if adding features)
• Code cleanup: $50k - EXPENSE (definitely maintenance)
The trap: Calling everything "enhancement" to capitalize more. Auditors aren't stupid. They'll check your Git commits.
Here's How We Make This Not Suck
No more spreadsheets. No more guessing. Just automated tracking that finance actually trusts.
Git Commits → Cost Allocation
We analyze your actual commits. Feature work gets capitalized. Bug fixes get expensed. No manual time tracking. Your developers will thank you.
Audit-Ready Reports
When the auditors show up (and they will), you hand them our report. Shows exactly what was capitalized, why, and the supporting evidence. They love that stuff.
Real-Time Tracking
See your capitalize vs expense ratio in real-time. No more surprises at quarter end. Know if you're trending too high or too low before finance asks.
R&D Tax Credit Bonus
While we're tracking for capitalization, we also identify R&D tax credit eligible work. That's usually another 10-15% you're leaving on the table.
Works With Your Agile Process
Sprints, kanban, whatever you use. We map your actual workflow to GAAP requirements. No changing how you work to fit accounting rules from the 1980s.
The Bottom Line for Your Bottom Line:
Most engineering teams are either over-capitalizing (audit risk) or under-capitalizing (paying too much tax). We've seen companies find $500k-$2M in legitimate capitalizable costs they were expensing.
ROI math: If you have 20 developers at $150k each, and you're capitalizing wrong by just 20%, that's $600k/year in misallocated costs. Our platform pays for itself in the first quarter.