Speakeasy | The Internet of SDKs
How Speakeasy is on a mission to build the API platform for every team.
Welcome to the latest edition of ‘The API Economy’ — thanks for being here.
To support The API Economy, be like the 4,470 early, forward-thinking people who subscribe for monthly-ish insights on the API economy, Web3, AI, and more emerging trends.
Hello everyone 👋 ,
Today’s edition of The API Economy is brought to you in partnership with Speakeasy.
Speakeasy’s founders Sagar Batchu and Simon Yu were kind enough to work with me on this edition of The API Economy. It would be an understatement to express my admiration for the exceptional Speakeasy team. Their remarkable vision for an SDK-first approach to API development is a paradigm shift for many. Collaborating with them has been an extraordinary experience.
Besides telling you how great the Speakeasy team is, I also want to tell you how they are changing API development as we know it by enabling teams of any size to build Stripe-quality APIs without a Stripe-sized team.
To find out how, let’s explore Speakeasy.
*Disclaimer: This is a paid sponsorship. Find out more about The API Economy’s paid sponsorships here.
The prism of APIs
An API is like a ray of sunlight, containing a spectrum of capabilities. Just as white light conceals a rainbow, a typical API hides its full potential. The power within most APIs is typically hard to harness because they are often hard to build, integrate with, and maintain. But in the right hands and with the right tool, an API can enable magical experiences far beyond the mundane.
Speakeasy is the prism that reveals the true possibilities within an API experience. The team at Speakeasy is building a complete platform to create world-class API developer experiences, from SDKs to Terraform providers, developer documentation, API maintenance, and more.
Tools to create SDKs are important because SDKs make the integration story easier. End-users are much more likely to adopt an API that has great SDKs. Simply put, better SDKs = better APIs.
According to Postman’s State of The API Report, over 75% of respondents somewhat agreed or strongly agreed that developers at API-first companies are more productive, create better software, and integrate faster with partners.
While APIs fuel innovation, working with them introduces significant integration challenges. There is the tedious work of managing data schemas, request authentication, business logic, rate limits, and other API capabilities so they align across systems.
Over the years, developers have had a conflicted relationship with APIs. On one hand, they've been crucial building blocks that allow applications to integrate with useful services and data. A great deal of effort is spent on this API plumbing before developers can even begin building creative solutions on top of them. As a result, API users struggle to exploit the value that APIs fully provide.
These data and functionality exchanges now drive the majority of traffic on the internet. Akamai says 83% of all internet traffic belongs to API-based services.
The company that finds ways to abstract away API & integration difficulties unlocks tremendous productivity gains. If we can reduce the time developers spend on mundane API configurations, they can instead spend more cycles innovating on top of API capabilities. Making APIs easier to build and manage makes them accelerators rather than anchors of developer experience.
This leads to Speakeasy redefining API development as we know it through their SDK-first approach.
SDKs all the way down
Since it will come up a lot in this piece, let’s start simply by defining what an SDK is.
An SDK (or Software Development Kit) is a collection of software tools and libraries that allows developers to build applications for a specific platform, software framework, or API. At a high level, SDKs provide pre-built abstractions on top of raw APIs, automatically handling authentication, serialization, retries, and other boilerplates.
Four key characteristics of SDKs:
Abstraction layer: SDKs provide an abstraction layer that hides API implementation complexity behind easy-to-use functions and objects. Developers don't work directly with raw API calls.
Packaged dependencies: SDKs include or automatically manage dependencies like authentication modules, serialization libraries, API clients, and other packaged functionality needed for integration.
Updates automatically: SDKs have mechanisms to automatically apply updates across all consumer applications without rebuilding integrations. This maintains compatibility with the latest API versions.
One of the biggest but most under-appreciated problems with APIs today is how challenging the go-to-market is for APIs. API producers must consider the ever-changing landscape of developer ecosystems: languages, runtimes, and marketplaces. API distribution is no longer as simple as building something and posting it on Hackernews.
API companies must consider API strategies holistically to meet developers where they are.
This is why for years, world-class API experiences seemed reserved only for API elites like Stripe and Twilio, who have entire teams of PMs, engineers, and technical writers, as well as dedicated platform tooling, all dedicated to ensuring that every API is easy to use and creating best-in-class programs.
Historically, most teams need more expertise and resources to build developer communities around their APIs. Creating rich SDKs, best-in-class docs, and robust monitoring — these capabilities required armies of specialized engineers, resulting in APIs remaining siloed with their potential bottled up.
The status quo ignores a fundamental truth: APIs are vital business drivers, not ancillary projects in the digital age. They unlock connectivity between systems and creativity between developers.
APIs are the threads weaving disjointed workflows into frictionless experiences — the foundations enabling rapid experimentation. When developers have unlimited choices of API building blocks to assemble solutions, companies live and die based on the quality of their developer experience.
SDKs, in particular, create vastly superior developer experiences compared to hand-coded API mashups. They completely abstract away unnecessary complexity like authentication rituals, network logic, and serialization. Developers can immediately focus on creating differentiated value instead of wrestling with APIs.
Companies can gain a competitive advantage by delivering magical moments in their SDKs to win in this landscape. And with SDK updates automatically applying improvements in the background, integration remains seamless over time.
The efficiency multiplier frees up tremendous cycles to build more ambitious solutions. In short, SDKs transform APIs from obstacles into on-ramps for innovation. They represent the future of fluid, frictionless developer experiences.
Yet, while APIs and most SDKs grow ever more central to success, the tools for building them have stagnated. Rudimentary documentation, hand-coded SDKs, DIY monitoring — the process for building APIs has been broken, leaving API producers with barely enough time and resources to build a functional API, let alone worry about how best to take the API to market across multiple language communities, handle API changes, or deal with consistency across the organization.
Meanwhile, API consumers wasted endless cycles reinventing the wheel for each integration. Here’s a typical developer workflow that every API user needs to repeat when integrating with an API today:
This is the chasm Speakeasy bridges. Its suite of automation tools brings Stripe-quality APIs within reach of any team. Speakeasy automatically creates and maintains critical developer surfaces like SDKs, Terraform providers, and docs that address the API go-to-market problem and provide tools that enable better API development and collaboration throughout the enterprise. So API producers don't need to build them themselves. API consumers can just import an SDK to integrate in seconds.
Tools like these that supercharge developers are crucial, considering more than 50% of companies have less than 50 developers in their entire organization, and teams of all sizes need a seamless way to grow API adoption.
Small teams are constantly being asked to do more with less.
The breakthrough lies in radically simplifying the consumer experience. Instead of forcing every API user to write their custom integration, Speakeasy creates best-in-class, feature-rich SDKs for every popular language. Now developers have the perfect on-ramp for building unique value quickly. Painstaking docs are dynamically assembled to complement these SDKs. Together, they accelerate adoption by erasing friction at the critical moment of integration while enforcing discipline in the API contract.
What started as APIs all the way down has become SDKs all the way down.
Simon relayed a customer anecdote that illustrates the transformative “time to integration” reduction that SDKs are providing to users:
“Let’s take the example of a ~500-person company that we’re working with. One of their teams integrated with an internal API a year ago. They reported it was a difficult, cumbersome, and lengthy process because the integration needed to be built by hand. The company started using Speakeasy SDKs for their internal APIs and recently integrated that same API again – but this time, completed the integration in just two days.”
The compounding effects over time are immense. Easy integration drives more diverse use cases and feedback, improving APIs faster. Evergreen SDK updates propagate improvements instantly across all consumers, preventing drift or instability. Increased rigor keeps the APIs reliable and resilient as they scale. As Speakeasy customer growth illustrates, these systems create runaway network effects.
In the past, the API consumer has taken on all the burden of making integrations robust and scalable. These consumers might be external, in which case the integration friction blocks revenue or internal to the company. Either way, this forces every user to design and implement their integration from scratch, causing code duplication and bugs, impacting reliability, and lowering developer productivity.
As the API economy has exploded and consumers struggle to integrate and work with the cognitive load of hundreds of APIs daily, API producers must shoulder this burden. The problem compounds at scale, with top SaaS companies having an average of 350 integrations and the biggest names in tech having well over a thousand integrations.
API producers often lack the financial and human resources to solve the change management challenges, from creating well-governed, designed APIs all the way through to creating great “last mile” developer experience artifacts like docs and SDKs.
When this occurs, API changes are no longer quick updates. One API change can impact a dozen developer surfaces and millions of end users. They become multi-week processes to update multiple developer surfaces, test, and publish — a cost-prohibitive activity for most developer teams.
That’s why SDK-first is the new API-first. SDKs are making API development exponentially easier. Importing an SDK creates a best-in-class API developer experience, solves bad documentation, and provides a better overall developer experience.
Developers can focus purely on innovating rather than integrating with SDKs.
“SDKs are essential tools for enhancing developer experience around a software tool. Specifically, not all developers have web API integration experience, so crafting resources catered to the unique programming language or platform they're accustomed to can do a lot to streamline the onboarding experience and get folks to that "Hello World" moment much quicker.
Of course, in the AI age, the expectation is to have development and integration knowledge closer to wherever the developer is working to increase productivity. So, I predict the future of API integration will move away from static documentation and traditional SDKs and toward AI-driven suggestions that are more ingrained into whatever IDE the developer is working in.”
The efficiency multiplier here cannot be overstated. For a reasonably sophisticated use case involving multiple API calls, an API consumer might need weeks or months to grok the API docs and build production-ready API integrations by hand. But SDKs bring that integration time down to a few minutes by eliminating the need to write custom integration code.
The efficiency gains directly accelerate developer velocity and innovation potential. APIs become building blocks instead of obstacles. In an increasingly composable technology landscape where new services launch daily, eliminating integration friction unlocks tremendous compounding value over time.
For producers, SDKs enforce API discipline and reliability across all implementations. While docs may grow outdated, SDKs automatically apply updates across all consumers via smart packaging systems. There is no fragmentation — improvements happen instantly.
This massively increases the resilience and longevity of APIs while reducing support burdens. The forced rigor also pays back in spades when evolving APIs. Established integrations stay intact while expanding capabilities for new users.
In essence, SDKs amplify the core value of APIs — reusable abstractions that consolidate complexity into simple building blocks for innovation. They preserve API contracts as sacred sources of truth while tailoring access for each specific environment.
When asked about the importance of SDKs, Sagar said:
“SDKs offer a consistent, reusable interface for integrating with an API, eliminating the need for every API consumer to reinvent the wheel. This increases engineering velocity, reduces toil, improves reliability, and reduces bugs in the codebase.
Creating an SDK forces treating the API spec as a sacred artifact. Once developers understand that maintaining the API spec results in tangible benefits to them and their API users, stronger consensus and workflows get built around keeping those specs up to date. Speakeasy provides tooling to build workflows around your specification for validation, enrichment, and merging.”
We’ve discussed the difficulties in building APIs, but APIs are equally (if not more) hard to maintain. Anything you build needs to be able to keep up-to-date with changing requirements, which is why, on average, developers spend 30% of their time coding APIs vs 70% doing other tasks.
According to Nordic API:
“29.5% of API developers’ time is spent programming and coding APIs, according to a Statista report on time allocation of application programming interface (API) tasks worldwide as of 2020. This is almost double the second most time-consuming task, manually debugging code, which clocks in at 17%. Both of these statistics reveal the necessity of tools like API testing and no-code or low-code programming environments. The more time you can shave off of unnecessary tasks, the more time you’ll have to spend on creating better APIs and building your business.”
All tasks are historically part of the territory when building an API. The numbers don’t lie; it’s a process with far too many complexities.
Speakeasy is uniquely addressing these difficult but fundamental problems. Their platform provides a build kit around the API that helps manage API changes effectively across multiple internal stakeholders, solving the supply chain issue associated with keeping all the critical API developer experience surfaces up-to-date. This ensures API consumers get the best possible integration experience via packaging most native to their development environment: a language-native, type-safe and feature-rich client SDK.
The secrets behind Speakeasy
When Sagar and Simon met, they quickly bonded over war stories from the trenches of API development. Both had battled the dysfunction firsthand — the scraped-together integrations, puzzling documentation, and brittle endpoints that broke without warning. Having fought to build and support APIs at their previous companies, they knew the heartache intimately.
They knew APIs represented the medium to accelerate innovation for businesses. But instead of seamlessly connecting systems, most acted as barriers that slowed progress to a crawl. The typical integration project stretches on for months while adoption languishes due to poor developer experience.
Then, after you build an API, you have to consider that, on average, it takes even more time to manage the API you’ve built and needs to be constantly tested to ensure functionality & security. This is true for both internal and external APIs.
With backing from Google Ventures and other top firms, Speakeasy is making it exponentially more accessible for companies to create, maintain, and extend APIs.
Speakeasy's original vision was to focus on API visibility — helping teams better document and test APIs for external developers. But in talking to API producers, Simon & Sagar quickly realized visibility was only half the battle. The real pain point was that integrations were still too hard. API producers were spending more effort writing never-ending reference and usage guides, but user adoption was still sluggish, while implementation costs to support new users stayed high. Every new API consumer built their integration from scratch, reinventing the wheel each time.
They saw that the better path was to simplify the entire API lifecycle. Instead of forcing developers to integrate with raw APIs, what if they could instantly access client SDKs in every major language? These SDKs offer standardized, battle-tested interfaces that eliminate the need for hand-built integrations. Developers could immediately build on APIs with no friction.
Sagar and Simon pivoted Speakeasy to help every team build better APIs from the ground up, starting with dramatically changing how API users consume APIs. By instantly enabling teams to generate SDKs alongside API docs and shifting the paradigm to SDK-first API consumption, they have solved core pain points for API producers and consumers. As a result, adoption has skyrocketed.
“Finding Speakeasy has been transformational in terms of our team's velocity. We've been able to progress our roadmap faster than we thought possible. We were able to get SDKs for 3 languages in production in a couple of weeks -- if we'd been on our own, it would probably have taken a month for each language. We also would likely have needed to hire developers with new language expertise that we don't necessarily have today.”
Real-world stories of companies leveraging Speakeasy to improve their API strategy dramatically come less than two years after Sagar and Simon founded the company in April 2022. With just a small distributed team spanning the US and UK, they have been laser-focused on the developer experience around APIs.
An SDK-first approach catalyzes a vitally important flywheel: Speakeasy has made it easier for teams to keep API specs rigorously updated. Once developers saw immediate SDK updates from any spec changes, they were motivated to maintain specs as the source of truth. Better specs also meant better SDKs and docs. This flywheel resulted in more reliable integrations across internal and external consumers. Bugs from outdated specs were also reduced, improving overall code quality.
The pivot was a breakthrough. Sagar and Simon realized the best way to transform API adoption was to simplify consumption radically. While visibility helped, seamless integration was the real driver of velocity. Speakeasy unlocked this with generated SDKs, creating the perfect gateway for developers to build on APIs. The approach was a win-win. Easier consumption meant more adoption, while rigor around specs improved reliability and cohesion. Together, they helped Speakeasy customers build better and reduce friction in the API lifecycle.
When asked how Speakeasy supports the API development lifecycle, Sagar told me:
“Speakeasy fits into a very natural place in developers’ workflows for managing API changes. We integrate seamlessly with all the tools they use today without requiring a “rip and replace” of existing systems or any steep learning curve — developers can continue to change the API and specification as they ordinarily do.
Our philosophy is to accelerate a dev team’s ability to ship great developer experience while giving them all the hooks they need to brand and customize to their liking. After all, developer experience is opinionated.”
Instead of building APIs through a convoluted process of sweat and tears, Sagar and Simon bring the power of automation and intelligence through Speakeasy. Just as APIs connect platforms, Speakeasy connects developers with the tools they need to innovate. What began as war stories is now a mission to become the API platform for teams across every company and industry.
The opportunity size before Speakeasy feels exponential and compounding for a few reasons:
Every company is poised to become an API company.
Even if every company isn’t a traditional tech company, APIs have become important at every type of company.
With Speakeasy, every company can more easily become an API company.
"Airbyte’s API is an important part of our platform. We recognized that to do it justice, we needed to make it as easy as possible to use. Great SDKs and docs are a fundamental part of that story.”
Speakeasy introduces enterprise-grade developer tools tailored for the modern API-driven company. No longer reserved just for the Stripes of the world, these capabilities become table stakes for any company where APIs are important to internal and/or external consumers.
Speakeasy handles the heavy lifting so engineering teams across the stack can focus on creating value, not reinventing wheels.
The future of software lies in tools that don't just connect systems but connect developers to the building blocks for imagination. Speakeasy liberates APIs from the Stone Age, representing a revolution in progress.
A future where integrations are natively composable
Popular AI tools like Writer help marketers automate brand voice & tone, initial research, and first-draft writing. Still, tools like this typically take your writing 80-90% of the way to completion, leaving it up to you to edit and finalize everything manually. Speakeasy is on its way to do the same thing for API development.
This is the early innings for API development-specific tools & SDKs. The proliferation of software, the importance of APIs, and the rise in AI make this the perfect time for a tool like Speakeasy.
In an essay about how Square automates SDK generation, author Kristopher Sandoval states:
"A Software Developer Kit, or SDK, is perhaps one of the most important things a web API can have. SDKs are a helpful system of libraries and frameworks to support the API, often including documentation and other guidelines.
What can’t be argued is their significance to developers. According to Tristan Sokol of Square, “If you think about the end-user experience, SDKs are the biggest touchpoints for people.” To this end, creating proper SDK material is highly vital to the success of an API."
AI systems, unlike humans, can process vast amounts of data rapidly and identify patterns undetectable to the human eye. This capability makes AI an ideal consumer for APIs, especially in data-heavy sectors. APIs designed for human use are becoming inadequate for AI's potential as AI evolves. This shift demands APIs catering to human and AI consumers, ensuring versatility and broader applicability.
Developing APIs for AI use means focusing on efficiency and scalability. AI systems require APIs that can handle large-scale data requests and deliver responses in formats suitable for machine processing. This transition poses a challenge for traditional API development, primarily considering human readability and ease of use. The dual-focus approach ensures that APIs remain flexible and robust, catering to diverse consumer needs.
The growing importance of AI-friendly APIs underscores the need for platforms like Speakeasy. Providing tools for SDK creation, Terraform providers, and meticulous developer documentation simplifies the development of human- and AI-friendly APIs. Speakeasy's emphasis on API maintenance ensures that these dual-purpose APIs remain efficient and up-to-date, catering to the evolving demands of AI systems and human developers.
As the API landscape continues to evolve with AI's growing prominence, platforms like Speakeasy have become indispensable for companies aiming to stay at the forefront of technology and innovation.
Simon has said that the market is responding to their bet on SDKs, saying:
“Some of our customer engagements have been initiated because their API users have demanded an SDK, perhaps as part of an RFP / competitive process. So I think we’re starting to see that SDKs are becoming more in demand in the industry — i.e. given similar services, you’d want to use the one that makes it easier for you to use and isn’t throwing up roadblocks.”
With the momentum Speakeasy has, it won’t be long until we start hearing SDK-first as often as we hear people say API-first. It’s only a matter of time.
Until our next adventure.
Thanks again to Sagar, Simon, and Tatiana from the Speakeasy team for working with me on this essay. Also, a special thanks to Mama Schroeder for editing this essay (any typos are on her 😊).
*Disclaimers: The views in this essay are my personal opinions and don’t necessarily represent the views of my employer or anyone other than myself. For more information on the sponsorship disclaimer for this newsletter, see here.