How to build a SaaS spend tracker

What matters here

• A SaaS spend tracker is four parts: an inventory with owners, contract terms, seats versus actual usage, and a renewal calendar.
• Track the notice date, not just the renewal date. An auto-renewal with a 90-day notice period is decided three months before it happens.
• Every subscription needs a named owner. Ownerless tools are the ones that renew forever because nobody feels responsible for cancelling them.
• Seats purchased versus seats active is where the money is. Total spend is a board number; unused seats are an actionable one.
• Shadow spend hides on cards, not in procurement. Reconcile against card and expense data or the inventory will be systematically incomplete.
• The tracker holds contract and vendor data, so scoped access and managed credentials belong in the plan from the start.

Who this is for

You run finance, procurement or IT, and you have been asked what the company spends on software. You know the big contracts. What you want is the long tail, the renewal dates, and evidence about which seats are actually being used.

How it works in practice

What you do with it across a year, and the two moments it saves you money.

1. 1

   Get everything into one register

   Vendor, product, cost, contract dates, notice period and a named owner. An entry with no owner is a finding, not a gap.

2. 2

   Work out when decisions are really due

   The app derives the notice deadline from the contract end and the notice period, and sorts everything by that instead.

3. 3

   See who is actually using what

   Seats bought against seats assigned against seats active in the last 90 days. The gap between the last two has a price on it.

4. 4

   Get warned with time to act

   Three configurable warnings before each notice deadline, to the owner, so a renewal becomes a decision instead of an event.

5. 5

   Find the tools nobody registered

   Recurring card and expense charges that match no subscription get surfaced for review. This list keeps producing results.

6. 6

   Record what you decided and why

   Renew, renegotiate, downgrade or cancel, with the usage evidence frozen at the time, so next year the reasoning still exists.

1. 1

   The register, and the date that actually matters

   One list, with the field most trackers leave out.

   Copy

   In this Helix project, build me a SaaS spend tracker.
   
   One record per subscription: vendor, product, what it is for, the owning
   team, a named owner, annual cost, currency, contract start and end,
   whether it auto-renews, the notice period in days, and a link to the
   contract.
   
   Now the important bit. Derive a notice deadline, which is the contract end
   minus the notice period, and treat that as the date that governs
   everything in this app. Sort by it, warn on it, report on it. A calendar
   built on renewal dates shows me contracts I can no longer cancel, which is
   an interesting fact and a useless one.
   
   Let me import from CSV with the column mapping in one file I can edit, and
   flag any subscription with no named owner. Ownerless tools are the ones
   that renew forever, because a shared inbox never feels responsible for
   cancelling anything.
   
   I sign in through Helix, so do not build a login page. Read the signed-in
   user from the runtime. And do not put any key or connection string in the
   code: if this needs to reach another system, tell me and I will create the
   connection in my workspace.

   Worth knowing. Notice deadline as a first-class derived field is the single most useful decision in this build.

2. 2

   Seats bought against seats used

   Where the money actually is.

   Copy

   Now add usage, because total spend is a board number and unused seats are
   an actionable one.
   
   Per subscription, let me load who has a seat and when they were last
   active. Then show seats purchased, seats assigned, seats active in the
   last 30, 60 and 90 days, and the annual value of the difference.
   
   Give me a reclaim list: assigned seats with no activity past a threshold I
   set, grouped by tool, ranked by what reclaiming them is worth.
   
   And flag seats still held by people who have left, if I give you a list of
   current staff. That list should be empty. It rarely is, and it is both a
   cost problem and an access problem.

3. 3

   Warn me while I can still act

   Turning a renewal from an event into a decision.

   Copy

   Build the renewal calendar next, ordered by notice deadline.
   
   For the next twelve months: vendor, annual cost, owner, and days
   remaining. Let me set three warning points, say 120, 60 and 30 days
   before the deadline, each one notifying the owner.
   
   Highlight anything auto-renewing that is already inside its notice window.
   Those are decided, and somebody should know that before the invoice
   arrives rather than after.
   
   When a renewal is decided, record the decision, who made it, the date, and
   the usage evidence as it stood at that moment. Six months later nobody can
   reconstruct why a renewal looked justified, and this is the fix.

   Worth knowing. Freezing the usage evidence at the moment of decision is what makes next year's conversation possible.

4. 4

   Find what the register does not know about

   Shadow spend, and the overlap nobody notices.

   Copy

   Two last reports.
   
   Let me import card and expense transactions and match them against known
   subscriptions by vendor name, allowing for the fact that the names will
   not match exactly. Anything recurring that matches nothing becomes a
   candidate for the register. Show me a review list rather than adding them
   automatically, because a recurring charge is not always a subscription.
   
   Then overlap: several subscriptions tagged with the same purpose, which is
   usually two teams buying the same category separately. That one tends to
   find the single largest saving and it needs nothing more than the purpose
   field I filled in at the start.

5. 5

   Connect it to real systems

   The step that turns a working prototype into something with your data in it.

   Copy

   Now connect it to the systems we actually run, so it works on real data
   rather than the rows you seeded.
   
   Anything in angle brackets is a placeholder. Swap it for whatever we use
   instead, and have the app name the connection it wants rather than assume
   a vendor, so changing my mind later is a config change and not a rewrite.
   
   <Okta>. Read who has an account in each tool and when they last signed in,
   which is where unused seats show up.
   
   <NetSuite>. Pull recurring card and invoice transactions, which is how you
   find the tools nobody registered.
   
   <each vendor admin API>. Read seat counts and last-active dates for the
   tools worth the effort.
   
   <Google Calendar>. Block the notice deadline in the owner's calendar, so
   the decision has time in it rather than an alert on the day.
   
   <Coupa>. Read contracts and renewal terms rather than retyping them out of
   PDFs.
   
   <Slack>. Warn the owner at each lead time before a notice deadline.
   
   <Snowflake>. Keep a dated snapshot each month, so a renewal-over-renewal
   price rise is visible rather than something you notice once.
   
   Only write where I have said to write. Everything else is read only.
   
   Do not write a key, a token or a connection string anywhere in the code,
   and do not ask me to paste one. Tell me which connections you need and I
   will create each as an authentication in my Helix workspace. Reference
   them by alias.

   Worth knowing. Every name in angle brackets is a placeholder for whatever you run. Helix holds the credential as a workspace authentication, so the app references an alias and never the secret itself.

6. 6

   Ship it

   The last step of every build: a URL, and the right people on it.

   Copy

   Deploy my app.

   Worth knowing. Your assistant runs helix deploy underneath and the app comes back as a URL. Contract terms and per-person usage are sensitive, so set Access Control before sharing: owners see their own tools, finance sees the whole register.

What it connects to

The register is only accurate if it is checked against what the systems actually report, rather than what somebody typed in.

• Okta

  Read who has an account in each tool and when they last signed in, which is where unused seats show up.

• NetSuite

  Pull recurring card and invoice transactions, which is how you find the tools nobody registered.

• Each vendor admin API

  Read seat counts and last-active dates for the tools worth the effort.

• Google Calendar

  Block the notice deadline in the owner's calendar, so the decision has time in it rather than an alert on the day.

• Coupa

  Read contracts and renewal terms rather than retyping them out of PDFs.

• Slack

  Warn the owner at each lead time before a notice deadline.

• Snowflake

  Keep a dated snapshot each month, so a renewal-over-renewal price rise is visible rather than something you notice once.

Each line says whether the app reads, writes or both. Anything not described as writing should be read only.

Named systems are the ones most teams actually run, not a list of the only ones that work. Swap in whatever you use.

Each connection is an authentication in your Helix workspace, referenced by alias. The app names the connection it wants and never holds the credential, so nothing here ends up in your code and any of it can be rotated or revoked without a redeploy.

Related guides