A discount is a percentage of a number nobody wrote down

Every procurement tool sells the same moment: the purchase. An intake form, an approval chain, a benchmark of what comparable companies paid, a negotiator who runs the call. It is a good product, and it is the wrong place to start when the company has eleven people.

Not because negotiation is worthless. Because a discount is a percentage of a number, and at eleven people the number usually lives in three different places: a card statement, a founder's memory, and a billing inbox nobody opens. The percentage has nothing to multiply.

Where small-team spend actually goes

We build a tool that reads billing email and produces a subscription list, so we have a biased view of the problem. Still, the arithmetic is not biased. Of every ten charges on a small company's card in a given quarter, most are not new purchases. They are renewals of decisions made months ago, sometimes by people who no longer work there. A purchase decision has a moment and a person attached. A renewal has a date and often no person at all.

That asymmetry explains a pattern we keep seeing in the complaints we collect: the person who asks "how do I cancel this" rarely asks about the purchase. They ask about the thing that renewed. Nobody negotiated it, because nobody knew it was coming.

What an inventory looks like as data

The useful artifact is not a dashboard. It is a table with one row per vendor and an append-only record of amounts. Two tables, nine columns, no magic:

create table subscription (
  id            uuid primary key,
  vendor        text not null,
  owner         text,
  interval      text not null,          -- monthly | yearly | one_time | unknown
  next_charge   date,
  status        text not null default 'active'
);

create table charge (
  id              uuid primary key,
  subscription_id uuid not null references subscription(id),
  amount          numeric(12,2) not null,
  currency        char(3) not null,
  charged_on      date not null,
  source_message  text not null,         -- the receipt this came from
  unique (subscription_id, charged_on, amount)
);

The unique key is doing quiet work. Parsing the same receipt twice is free; the second insert is a no-op. next_charge is derived from the most recent charge plus the interval, never typed by hand, because a hand-typed date is a promise nobody checked.

The query that earns the table back is short:

select s.vendor, s.owner, s.next_charge, c.amount, c.currency
from subscription s
join lateral (
  select amount, currency from charge
  where subscription_id = s.id
  order by charged_on desc limit 1
) c on true
where s.status = 'active'
  and s.next_charge <= current_date + interval '14 days'
order by s.next_charge;

Fourteen days is a product decision, not a law. The point is that the window is a query, so it can be a weekly email instead of a meeting.

The leak that negotiation cannot see

A price change is the second signal the two-table shape gives you for free. When the latest amount differs from the previous one for the same vendor, something happened: a tier moved, a seat was added, a promo ended. No procurement process is involved in that event. It is a diff between two rows.

select subscription_id, amount, charged_on
from charge c1
where exists (
  select 1 from charge c2
  where c2.subscription_id = c1.subscription_id
    and c2.charged_on < c1.charged_on
    and c2.amount <> c1.amount
);

Run that once and you will find at least one vendor where the amount went up and nobody chose it. That is the leak, and it is invisible to any tool that only models purchases.

Where a buying platform earns its price

None of this argues against negotiation. It argues for sequence. Once the list exists, three things become possible that were guesses before:

• You know which vendors are large enough to be worth a call. Most are not; the tail is small and frequent.
• You know the exact renewal date, so a negotiation has a deadline instead of a vibe.
• You can tell a benchmark apart from your own bill. The benchmark says what a fair price is; your charge row says what you are paying.

Companies that get to a hundred people and start signing multi-year agreements should absolutely bring in a negotiation service. The stage where that pays for itself arrives later than founders expect, and it arrives right after the inventory problem is solved. Until then, the discount is theoretical.

Ownership is the part software cannot do

One row, one owner, one date. Our free scan builds the first two tables from twelve months of billing email with a read-only mailbox scope; renewal alerts go out fourteen days before the charge. What it cannot do is decide that the row belongs to a person. Fifteen minutes a week, one dated list, someone who notices. That is the whole management system at this size, and it is the input every bigger system assumes already exists.

If you want to see what the list says about your own company, the scan is free and takes one mailbox.