Jeff Lawson didn’t bring a deck to his 2008 pitch meeting with Fred Wilson. He brought a laptop.
Then he started typing.
By the time he finished, Wilson’s own phone was ringing. No slides. No projections. Just five API calls turning global telephony into something a developer could touch in real time.
That moment wasn’t a magic trick. It was the first proof point of a developer trust strategy that would eventually build a multibillion-dollar company. I’ve spent my career watching founders chase market size and buzzwords. Lawson chased something rarer: credibility with the people who actually build things.
▶️ Listen to this episode
[ Apple Podcasts ] [ YouTube ]
The Problem Wasn’t Ideas. It Was Access.
Before Twilio, connecting software to a phone line meant writing checks to carriers and waiting years for hardware. That’s not a technical bottleneck. That’s a business model designed to keep builders dependent on gatekeepers.
Lawson had hit that wall repeatedly at his earlier companies. So Twilio’s founding bet was simple: take a massive capital expense and turn it into a line of code billed to a credit card.
That’s not just clever engineering. It’s a go-to-market insight most executives miss. The biggest unlock isn’t always a new feature. Sometimes it’s removing a barrier nobody thought was removable.
Every Company Became a Software Company
Around 2010, the ground shifted under enterprise buyers. Banks, airlines, and retailers stopped thinking of themselves as institutions with an app. They started thinking of themselves as software companies with a business attached.
That shift created a new power center inside every organization: developers. Traditional telco vendors kept doing what they’d always done—golf outings, executive dinners, long sales cycles.
Twilio skipped all of it and went straight to the people writing code.
That’s the part I find instructive. Most B2B marketing still defaults to chasing the signer first. Twilio built its developer trust strategy around a different sequence: win the builder, and the budget conversation takes care of itself later.
From Prototype to Procurement
The early playbook worked. If a developer could build something functional in an afternoon, Twilio had a design win. Uber and WhatsApp adopted it early, and adoption spread fast through pure product experience.
But bottom-up growth has a ceiling, and Twilio hit it.
The Concentration Problem
At one point, a single customer like Uber represented a meaningful share of revenue. The people using the product daily had zero relationship with the people signing the contract.
When that customer decided to cut costs, Twilio felt it immediately. Developer love had gotten them in the door. It wasn’t enough to keep them in the building.
Building the Boring Stuff
So between roughly 2013 and 2017, Twilio did something a lot of growth-stage companies resist: it invested heavily in features that don’t excite anyone in a demo. Security certifications. SOC 2 compliance. ISO 27001. Admin tooling.
None of that trends on a product roadmap slide. All of it is what actually closes enterprise deals.
I’ve sat in enough renewal conversations to know this pattern well. The feature that gets a prototype built is rarely the feature that gets a seven-figure contract renewed. Twilio understood that developer affection was the foundation, not the finish line.
Marketing That Doesn’t Look Like Marketing
Here’s the paradox at the center of Twilio’s growth: its most effective marketing barely resembled marketing at all.
Developers can smell a sales pitch from across a hackathon floor. So Twilio’s team operated on one rule—show up and help, no strings attached. Evangelists in red jackets sat on the floor debugging localhost issues, sometimes for developers running a competitor’s product.
That’s not generosity for its own sake. It’s a long-term trust deposit. When the developer eventually needed a communications API, there was only one name they associated with actually helping them.
Turning Trust Into a Boardroom Conversation
The billboard campaign around Twilio’s 2016 IPO took that trust and pointed it upward. “Ask Your Developer” wasn’t written for developers. It was written for executives tired of hearing that a digital project would take years.
Executives went back to their teams and asked. The developers, many already building on Twilio, had answers ready.
That’s a sharp piece of strategic sequencing. Build grassroots credibility first. Then let that credibility do the persuading for you at the exact moment leadership is asking the question.
Solving the Silo Problem
By 2020, the company saw a new failure mode emerging. Customers had communication channels but no shared context. A buyer might get a marketing email from one team and a conflicting support text from another.
Twilio’s roughly $3.2 billion acquisition of Segment addressed that directly, connecting messaging channels to a unified customer profile. The company was no longer just moving messages. It was trying to make every message informed by the same understanding of who the customer actually is.
Today, under CEO Khozema Shipchandler and Chief Product Officer Inbal Shani, that same logic is extending into agentic AI—moving from rigid “if this, then that” workflows toward systems that reason across channels before a message is even drafted.
What This Means for Leaders Outside Tech
You don’t need to sell APIs to learn from this.
Twilio’s developer trust strategy scales down to a simple principle: find the people closest to the problem, earn their trust through genuine usefulness, and let that trust travel upward through the organization on its own.
A few lessons I’d take into any strategy session:
Solve for the people doing the work, but build for the people signing the check. Bottom-up adoption wins market share. Enterprise readiness makes it durable.
Follow the customer’s actual problem, not your original roadmap. Twilio launched with voice. Customers asked for SMS. It followed them.
Treat your documentation and content like a newsroom, not a brochure. A competitor can copy your features. They can’t easily copy years of genuinely useful content.
You cannot manufacture trust with a technical audience. You can only earn it, repeatedly, by being useful when nobody’s watching.
The Real Takeaway
Twilio didn’t win because it had better APIs than everyone else. Plenty of companies had decent APIs.
It won because it treated developer trust as the actual product, and let the infrastructure follow.
That’s a harder strategy to execute than it sounds. It requires patience most quarterly-minded executives don’t have. But if you’re building anything that technical people need to adopt before anyone else signs off on it, this is the only sequence that has ever reliably worked.