Your data team just signed the contract: roughly $197,000 a year for Collibra's data intelligence platform, three years, plus a six-figure implementation on top. The platform goes live, the invoices start landing, and now the uncomfortable question reaches your desk — how much of this hits the P&L this year, and how much belongs on the balance sheet? Get it wrong in either direction and the damage is real: expense everything and your go-live year absorbs half a million dollars that should have been spread over the contract term, cratering EBITDA right when a lender or investor is watching; capitalize the subscription fees themselves and you have inflated assets that an auditor will unwind. The rules that decide this live in ASC 350-40, and they turn on distinctions — license versus service contract, preliminary versus application-development stage — that your vendor's order form never spells out.
This post walks through what a buyer actually receives in a Collibra deal, the license-versus-service-contract fork that controls the whole analysis, which implementation costs capitalize and which expense, how to amortize what you capitalize, and the coming ASU 2025-06 rewrite you should be preparing for now.
What You Are Actually Buying
Collibra sells a data intelligence platform for governing, cataloging, and monitoring enterprise data and AI assets: data discovery, lineage tracking, data quality management, and policy enforcement across the data estate. Third-party pricing benchmarks put the median buyer at about $197,142 per year, with a typical range from roughly $174,740 to $225,360, and enterprise contracts reported anywhere from $170,000 to over $510,000 a year depending on modules, users, and data volume. The platform comes in Standard and Premier tiers — both with one production and one non-production environment — differing mainly in creator seats and metadata integrations: 10 standard users and 5 integrations on Standard, versus 20 creator users and unlimited integrations on Premier, with unlimited read-only viewers on both.
Two facts about the deal shape the accounting before you open the Codification. First, Collibra is available as SaaS or self-hosted, and that choice is the single biggest determinant of how you book the arrangement. Second, the subscription is only part of the spend: third-party analyses report implementation timelines of 6 to 12 months with $150,000 to $500,000 in professional services on top of the license. When the implementation costs as much as a year of subscription, the capitalize-versus-expense decision on those services moves your financials more than the subscription itself.
The Fork That Controls Everything: License or Service Contract
Before touching any invoice, you must classify the arrangement itself. Under ASC 350-40, as clarified years ago for cloud deals, a hosting arrangement is either a software license or a service contract, and the test has two prongs — both must be met for license treatment:
- You have a contractual right to take possession of the software at any time during the hosting period without significant penalty.
- It is feasible for you to run the software on your own hardware or to contract with another party to host it.
A self-hosted Collibra deployment that you install in your own environment generally satisfies both prongs: you hold the software, and you could operate it or move it. That is a software license, and the license fee is accounted for as internal-use software — capitalized and amortized. A SaaS subscription where the platform runs in Collibra's cloud, by contrast, almost never satisfies the first prong: you cannot take possession of the vendor's hosted service in any meaningful sense. That is a service contract. The subscription fees are expensed as incurred (prepayments sit in a prepaid asset and release ratably), and only certain implementation costs are eligible for capitalization under the rules ASU 2018-15 added to Subtopic 350-40.
Most Collibra buyers today sign the SaaS form, so the rest of this post assumes a service contract. If you negotiated a self-hosted deal with a take-possession right, your license fee capitalizes — but the implementation analysis below still applies to the services around it.
The Three Project Stages
For a service contract, ASU 2018-15 says to evaluate implementation costs the same way you would evaluate costs of an internal-use software project: by the stage in which they are incurred. There are three stages, and the stage — not the vendor or the invoice label — decides the treatment.
Preliminary project stage: expense
Everything before the build is expensed as incurred: evaluating vendors, sitting through demos, running the proof of concept, selecting Collibra, negotiating the contract, and planning the rollout. The hours your data architect spent comparing catalog tools, the legal fees on the order form, the travel to a reference customer — all period expense. A common error is sweeping pre-signature consulting into the capitalized asset because the same integrator later did the implementation. The standard does not care who sent the invoice; work performed before the project was authorized and committed to funding belongs to the preliminary stage.
Application development stage: capitalize
Once management has authorized the project, committed to funding it, and completion is probable, costs incurred to get the system ready for its intended use capitalize. For a Collibra rollout this is the largest bucket, and it is where the six-figure implementation spend mostly lands:
- Configuration and customization of the platform: operating-model setup, asset types, domains, communities, and custom workflows.
- Building integrations and interfaces: metadata ingestion connectors, lineage harvesters, API connections to your warehouse, BI tools, and ticketing systems.
- Direct coding and scripting specific to your environment: custom Groovy or Java workflow code, migration scripts, interface mapping logic.
- Testing and installation: system testing, user acceptance testing, parallel runs, and the cutover effort.
Payroll costs of employees directly devoted to these activities capitalize too, including the related payroll taxes and benefits — not only the integrator's fees. If two of your data engineers spend four months full-time building lineage integrations, that compensation is part of the asset, and you need time records to support it.
Post-implementation stage: expense
After go-live, the treatment flips back to expense: training end users and stewards, ongoing maintenance and support, minor tweaks and tuning, and data conversion and cleanup that is not required to make the software operational. Training is the trap here — Collibra rollouts involve heavy steward enablement, and every dollar of it expenses, no matter how essential it feels to the project's success. Data cleanup deserves a careful read: scrubbing your business glossary and certifying data quality rules is usually about your data, not about getting the software ready, so it expenses; writing the migration routines that load cleansed metadata into the platform during the build capitalizes. Document which is which while the work happens, because reconstructing it at year-end from a single blended statement of work is where audit adjustments are born.
What This Means for the $197K Line Item
Put the stages together and a typical three-year Collibra SaaS deal books in three pieces.
First, the subscription itself — say $197,142 a year — expenses ratably over the term it covers. If you prepaid the year, the cash goes to a prepaid asset and releases monthly at $16,428.50; nothing about a multi-year commitment makes the fee itself capitalizable. A multi-year prepayment is still a prepayment, with the beyond-twelve-months portion sitting in a non-current asset.
Second, the capitalized implementation costs — the integrator fees, configuration labor, interface builds, and testing from the application-development stage — form an intangible asset amortized straight-line over the hosting term, including renewal periods you are reasonably certain to take. A three-year deal you fully expect to renew for two more years amortizes over five, not three; a three-year deal with no renewal conviction amortizes over three. That "reasonably certain" judgment is yours to make and document — renewal history, switching costs, and the depth of your lineage integration all support it — and auditors test it, because each added year trims the annual charge.
Third, presentation follows the economics the FASB envisioned: the capitalized implementation asset sits on the balance sheet in the same line item as any prepayment for the hosting fees, and each period's amortization lands in the same income-statement line as the hosting fees themselves — not in a separate amortization line. Disclose the arrangement's nature, the capitalized amount, the amortization method and expense, and any impairment. And impairment is not theoretical: if you abandon the rollout, consolidate onto another catalog, or gut the scope, you test the asset for recoverability like any long-lived asset and write down what will not be recovered.
One more consequence worth stating plainly: capitalizing the implementation raises EBITDA in the go-live year relative to expensing it, because amortization sits below the EBITDA line while services expense sits above it. That is the correct answer under GAAP when the criteria are met — not earnings management — but it means the classification decision can move covenant ratios and valuation multiples. Lenders and acquirers will ask for the schedule, so keep one they can follow.
ASU 2025-06 Is Rewriting the Rules
In September 2025 the FASB issued ASU 2025-06, targeted improvements to the internal-use software guidance, and it directly affects this analysis. The update removes all references to project stages from Subtopic 350-40 — the preliminary / application-development / post-implementation model this post just walked through. In its place, capitalization begins when two conditions are both met: management with the relevant authority has authorized and committed to funding the project, and it is probable the project will be completed and the software used to perform its intended function (the "probable-to-complete" threshold). The change is aimed at modern agile development, where work does not arrive in neat waterfall stages, and it applies to cloud implementation costs as well as built software.
The update is effective for annual periods beginning after December 15, 2027 — January 1, 2028 for calendar-year companies — with early adoption permitted. What should you do in the meantime? Keep accounting under today's stage model, but start documenting the two new triggers now: written funding authorization and a contemporaneous probability assessment. Projects that straddle adoption will be far easier to transition if the authorization memo already exists, and the discipline of writing down why completion is probable is the same discipline that supports today's application-development-stage calls.
Booking It in a Plain-Text Ledger
The mechanics are straightforward once the analysis is done: separate accounts for the prepaid subscription, the capitalized implementation asset, and the amortization expense keep each piece visible. Suppose you prepay year one of the subscription at $197,142 and capitalize $180,000 of implementation costs to amortize over 36 months ($5,000 a month). Month-end then releases $16,428.50 of subscription plus $5,000 of implementation amortization:
2026-02-01 open Assets:Checking
2026-02-01 open Assets:Prepaid:Collibra-Subscription
2026-02-01 open Assets:Capitalized-Software:Collibra-Implementation
2026-02-01 open Expenses:Software-Amortization
2026-02-01 * "Collibra" "Prepay year 1 of 3-year SaaS subscription"
Assets:Prepaid:Collibra-Subscription 197142.00 USD
Assets:Checking
2026-04-15 * "Systems integrator" "Capitalized Collibra implementation costs"
Assets:Capitalized-Software:Collibra-Implementation 180000.00 USD
Assets:Checking
2026-04-30 * "Month-end" "Amortize subscription and implementation"
Expenses:Software-Amortization 21428.50 USD
Assets:Prepaid:Collibra-Subscription -16428.50 USD
Assets:Capitalized-Software:Collibra-Implementation -5000.00 USDA separate implementation asset per platform matters more than it looks: when you later impair, abandon, or finish amortizing one system, its carrying amount is one balance to read off, not a forensic exercise across a blended software account. If you keep your books in Beancount, the Fava dashboard turns these accounts into a live amortization schedule — the prepaid balance draining monthly and the implementation asset stepping down — so the "reasonably certain" renewal judgment and the remaining term stay visible instead of living in a spreadsheet only one person understands. The general documentation covers account setup and balance assertions if you want to pin each month's expected balances so a missed amortization entry fails loudly.
Mistakes That Draw Audit Adjustments
Most Collibra-scale adjustments fall into a short list. Capitalizing the subscription fee is the largest single error — no term length and no prepayment converts a service-contract fee into an asset. Expensing the entire implementation is the mirror image, and it understates assets while making the go-live year look worse than GAAP intends. Amortizing over the initial term when renewal is reasonably certain (or over hoped-for renewals that are not) misstates every period's charge; write the memo, cite the evidence, and revisit it annually. Capitalizing training and data cleanup because they arrived on the integrator's invoice ignores the stage test — read the statement of work line by line and split blended invoices before booking. And booking employee time without time records leaves the capitalized payroll unsupported; a one-line monthly allocation certified by the project lead is the minimum an auditor will accept.
Close the loop this month by pulling your own Collibra order form and statements of work, sorting every line into the three stages, and confirming the amortization period matches the term plus only the renewals you can defend as reasonably certain. The $197K subscription was the easy part — it expenses ratably and nobody argues about it. The implementation is where your balance sheet is actually decided, and the documentation you write while the project is fresh is what protects that asset when someone asks about it two years from now.
