DEV Community

Cover image for Your Biggest Customer Can Leave Without Canceling Anything
Sonia Bobrik
Sonia Bobrik

Posted on

Your Biggest Customer Can Leave Without Canceling Anything

Landing a famous logo feels like the moment a project becomes real: the traffic graphs bend upward, the invoices grow an extra digit, and somebody creates a Slack channel named after the customer. Finance people read that same moment very differently, and this clear-eyed breakdown of what it costs to depend on one big customer shows how lenders, investors and acquirers put a price on it. Engineers pay their share of the bill earlier, in a currency that never appears on a balance sheet: special-case code paths, on-call pages, roadmap slots, and the strange way a team gradually starts to resemble its biggest client.

This post is about the engineering half of that bill, and about a detail that is easy to miss if you build usage-priced APIs or infrastructure. A big customer does not have to cancel anything to hurt you. It only has to send you a little less traffic.

Twelve percent was enough

On May 2, 2017, Twilio reported the kind of quarter most startups would frame and hang on the wall: revenue of $87.4 million, up 47 percent from a year earlier and well ahead of analyst estimates. Within hours, its shares were down about 30 percent in after-hours trading. The reason was Uber, which had supplied 17 percent of Twilio's revenue in the previous quarter and 12 percent in this one, and which was now routing fewer of its texts and calls through Twilio. What stands out in TechCrunch's report on Uber pulling back from Twilio is the scale of the damage: one customer erased close to a billion dollars of market value from a company that had just added 4,000 new customers in a single quarter.

Uber never tore up a contract, and Twilio's own quarterly filing explains why it didn't need to. Uber had signed a minimum-commitment agreement, but its real usage ran far above that floor, so it could cut back sharply without notice or penalty. CEO Jeff Lawson told analysts the shift was happening by use case and by geography, with Uber spreading the work across other providers and its own in-house systems. He called Uber "an outlier," arguing that only a customer spending at that level could justify such a large engineering effort. WhatsApp, Twilio's other giant account, used Twilio's messaging and voice APIs to verify its users and had no long-term contract at all. Its share of Twilio's revenue slid from 17 percent in 2015 to 9 percent in 2016 and 5 percent in the first half of 2017, and there was never a contract to cancel.

Three years later, the same film played at Fastly. In August 2020, its CEO told analysts that TikTok had accounted for about 12 percent of revenue in the first half of the year. In October, Fastly warned that geopolitical uncertainty had pushed usage by its largest customer below expectations, added that a few other accounts had also used less than forecast, and cut its third-quarter revenue outlook to $70 million to $71 million, down from $73.5 million to $75.5 million. CNBC's report on Fastly's lowered guidance shows how hard that landed on one of the year's hottest stocks: shares fell as much as 28 percent after hours, following a run of more than 500 percent since January. The company's press release summed up the problem in six words, saying the results reflected "the challenges of a usage-based model."

Put the two stories side by side and two lessons fall out. The first is that 12 percent looks harmless on a pie chart. Twilio trimmed its full-year forecast by about 2 percent and Fastly its quarterly forecast by about 5 percent, yet each lost roughly a quarter of its market value in a single trading day. Markets, like your hiring plan, are built on growth, and a whale's share of your growth can be far larger than its share of your revenue. Twilio's business outside Uber was growing about 60 percent a year; the one big account was what bent the curve.

The second lesson is the one this post is named after. In a usage-priced business, the whale never has to send a termination letter. It can leave by degrees, one region, one use case, one routing rule at a time, and the first place that shows up is not your CRM. It is your traffic graphs.

Conway's law, pointed at your customer

In 1968, Melvin Conway observed that organizations build systems that mirror their own communication structures. Give a team one dominant customer and the law flips direction: the system starts to mirror the organization that buys it.

It usually begins with a conditional. Somewhere in the request path, a line appears that checks whether the account ID belongs to the big customer, because they need a different rate limit, an extra column in the export, or a retry policy their integration team insists on. Next comes a dedicated deployment, because their security review won't accept shared infrastructure. Then a pinned API version, because their change board approves upgrades twice a year, and release dates that drift toward their maintenance windows. Their escalation path becomes your severity scale. Their quarterly business review becomes your planning meeting. Sooner or later there is a team whose entire job is one account, and the architecture dutifully grows a seam exactly where that team's responsibilities begin and end.

Each of those decisions is defensible on its own, which is why the pattern is so hard to spot. Every custom integration raises the customer's switching cost, and that feels like a moat. It behaves more like a mortgage. You make payments on it every sprint in maintenance, testing and on-call load, and the payments continue after the customer starts moving traffic elsewhere. The rest of your market pays too. Features that hundreds of smaller accounts need slip a quarter, then two, which makes the product a little less appealing to everyone who isn't the whale, which pushes the whale's share up a little further. Concentration feeds itself unless someone deliberately breaks the loop.

Measure it like you measure latency

Most teams can quote their p99 latency to the millisecond and have no idea how concentrated their revenue is. Fixing that takes about a dozen lines of code, and two numbers tell you more than the usual "top customer percentage."

The first is the effective number of customers: one divided by the sum of every customer's squared share of revenue. That sum is the Herfindahl-Hirschman index, which antitrust economists use to measure market concentration. Political scientists use the same formula to count the effective number of parties in a parliament, and ecologists use it to estimate species diversity. The second is the biggest customer's share of growth, which is the number Twilio's and Fastly's investors were really reacting to.

def concentration(now: dict[str, float], before: dict[str, float]) -> dict:
    total = sum(now.values())
    shares = sorted((v / total for v in now.values()), reverse=True)

    growth = [v - before.get(k, 0) for k, v in now.items()]
    net_growth = sum(growth)

    return {
        "customers": len(now),
        "top_share": round(shares[0], 2),
        "effective_customers": round(1 / sum(s * s for s in shares), 1),
        "top_share_of_growth": round(max(growth) / net_growth, 2) if net_growth > 0 else None,
    }


before = {"whale": 100_000, **{f"acct_{i}": 9_000 for i in range(70)}}
now = {"whale": 300_000, **{f"acct_{i}": 10_000 for i in range(70)}}

print(concentration(now, before))
# {'customers': 71, 'top_share': 0.3, 'effective_customers': 10.3, 'top_share_of_growth': 0.74}
Enter fullscreen mode Exit fullscreen mode

Seventy-one customers on the dashboard, about ten in practice, and one of them supplies three quarters of the growth that every forecast and hiring plan is built on. Recompute these numbers monthly, put them next to your SLOs, and alert on the trend rather than the level. Because usage-priced whales leave gradually, the most valuable signal is the derivative. A top account whose traffic stays flat while its own business is booming, or whose volume is sliding in one region, is telling you something before any account manager hears about it. So is a large customer that starts hiring engineers to build the exact capability it currently buys from you.

Defusing the whale without losing it

None of this is an argument against big customers. They bring scaling problems worth solving, credibility that opens doors, and the hardest feedback you will ever receive. The goal is to keep your ability to say no, and a handful of habits protect it:

  • Turn special cases into settings. Every if account_id == BIG_CO should become a per-tenant configuration flag, a webhook or an extension point that any customer could use. If a request truly can't be generalized, treat it as a paid project with an owner and an end date, not as a product feature.
  • Keep one trunk. Refuse long-lived customer branches and private forks. If a customer needs stability, offer a versioned API or a long-term-support channel with a published support window, and price it like the extra work it is.
  • Make discounts buy commitment. Twilio's filing is the cautionary tale: a minimum commitment far below real usage protects you only down to that floor. Volume discounts should come with committed spend that sits close to what the customer actually uses.
  • Cap the roadmap share. Decide what fraction of each sprint a single account may consume, write the number on the planning board, and change it on purpose instead of letting escalations change it for you.
  • Size your own commitments for the long tail. Reserved instances, savings plans and multi-year vendor contracts signed to serve one whale keep billing you after that whale shrinks, so count them as part of your exposure.
  • Run a whale fire drill. Once a quarter, model the month after your largest customer halves its usage: runway, idle infrastructure, and which people and services were dedicated to it. It is chaos engineering for revenue, and it costs far less than the real thing.

If you freelance, or you're about to sign an offer

All of this scales down to one person. A freelancer whose main client pays 80 percent of the bills has a job without the benefits, and the same habits apply. Keep a second client even when the first could fill your week, keep reusable work in code you own where your contract allows it, and hold a cash buffer at least as long as the client's notice period. Raising your rate for the dominant client is often the healthiest move available, because it either buys you time to diversify or makes the decision for you.

If you're interviewing at a startup or an agency, ask the question almost nobody asks: what share of revenue comes from the largest customer, and how has that changed over the past year? Then ask whether any team works for a single account. The answers tell you whose roadmap you would really be building, and how quickly your job could change if one procurement department changes its mind. For public companies, the annual report often answers the first question before you get to the interview.

The real asset is the right to say no

Every company starts at 100 percent concentration, because the first customer is the only customer. That's a phase, not a failure. What carried Twilio through its whale problem was the base underneath it: more than 40,000 active accounts, a business outside Uber growing at 60 percent, and a third-largest customer worth just 2 percent of revenue. Uber cost Twilio a brutal month on the stock market. The long tail was the actual company.

So track concentration as seriously as uptime, build for your biggest customer through extension points instead of exceptions, and keep shipping for the customers too small to have your phone number. They are the reason you'll still be standing when the biggest one decides to route its traffic somewhere else.

Top comments (0)