If you’re the founder of a VC-backed software business, you should have a plan to reach $100 Million ARR at some point in your company’s journey. But not all founders do. I recently shared Christoph Janz’s Five Ways to Build a $100 Million Business with a Series A startup CEO. In this seminal essay, Janz describes the type and number of “clients” a company needs to have, from consumers to enterprise customers, to generate $100 Million yearly revenue.
While Janz’s model makes sense for many “Internet” companies (he wrote the original version in 2014), I believe it lacks two essential dimensions for developer-first businesses. The first one is the recent focus on user experience for enterprise companies, building products that professional users love and recommend to their boss/purchasing department. This phenomenon allowed enterprise companies to dare to offer free product tiers to lure users in the hope they would later convert their organisation (the infamous “product-led growth”). The second dimension Janz’s model lacks is the specificity of selling to developers.
As I wrote in my last piece, companies selling to developers are now in a $64B ARR market. But you don’t sell to developers like you sell to salespeople or accountants. Developers are the toughest software buyers, and even in large corporations, decision-makers now increasingly consider their point of view before making a purchasing decision.
In this essay, I’d like to offer an adaptation of Christoph Janz's model, focused on developer-first companies, where companies don’t address one type of customer or the other, but all of them at different stages of their growth.
How to Build a $100 Million Developer-First Business
To build a developer-first company with $100 million in annual revenues, based only on Janz's model, you need:
- 10 million independent developers (flies), essentially consumers, who you monetise at $10+ per year with ads;
- 1 million professional developers (mice), personally paying you, or expensing, $100+ per year;
- 100,000 teams or startups (rabbits) paying your $1k+ per year each to solve challenges at the development team level, and usually purchased by a manager;
- 10,000 SMBs or scale-ups (deers) paying you $10k+ per year each to solve challenges at the engineering department level, and usually purchased directly by the CTO;
- 1,000 large enterprise customers (elephants) paying you $100k+ per year each to solve complex challenges at the organisational level and usually purchased by a CIO / CTO + purchasing.
Let's dive into each segment.
Segment 1: Independent Developers
The vast ocean of independent developers is the first segment in the quest to build a $100 million developer-first business. For a company to make $100 million in yearly revenue leveraging only individual developers, they would need to attract a large audience, over 10 million people, paying $10 or more per year, often through advertising models. I don’t think any “consumer” company focusing on the developer community ever made such revenue as Stack Overflow, with over 20 million registered users, made around $90M revenue in 2022.
But this doesn’t mean developer-first companies should disregard individual developers, especially those looking to interact with the product for free, who could become ambassadors in the process. Those users would then contribute to forums, write blogs, create tutorials, or speak at conferences, further amplifying the product's reach. Their endorsement is a testament to the product's efficacy and value, making it more attractive to potential paying customers in higher segments.
Having an open-source version of the product also falls into this category. By engaging developers in the open-source process, companies can cultivate a sense of ownership and loyalty among users. These developers can contribute to the product's improvement through feedback, code contributions, and sharing their experiences within their networks.
Segment 2: Professional Developers
The second critical segment in building a $100 million developer-first business focuses on professional developers. To reach the $100 million mark, a company must engage approximately 1 million professional developers, each paying $100 or more annually. This revenue often comes through direct payments for premium tools and services. GitHub is a prominent example of this model, having successfully converted a substantial user base of professionals into paying customers.
In this scenario, professional developers seek tools that offer advanced functionalities, greater efficiency, or customisation options beyond what free or open-source tools can provide. However, this discerning customer base tends to be sceptical of paid products, especially when free alternatives are available.
To tap into this market, developer-first companies must offer distinct, tangible value that justifies the investment. This could be through superior performance, unique features, integration capabilities, or exceptional user experience, allowing professional developers to be more productive. Moreover, in a landscape where word-of-mouth and peer recommendations carry significant weight, the satisfaction and endorsement of current users become invaluable to convert a whole team.
Segment 3: Teams & Early-Stage Startups
To effectively target this group, companies need to attract around 100,000 customers, each paying roughly $1,000 per year. Success in this segment often hinges on providing tools and services that streamline the software delivery lifecycle or mandatory services to host a live application.
Unlike individual developers, engineering teams require tools that facilitate coding and aid in version control, CI/CD, testing, and monitoring. Products like Atlassian’s Jira, Bitbucket, or GitLab offer integrated solutions that streamline these processes, making them ideal for teams looking to enhance productivity and collaboration. These tools must be intuitive yet powerful, offering scalability as teams grow and projects become more complex.
Early-stage startups usually require foundational services essential for hosting and running their applications in a production environment. These services, like cloud computing, are probably the ones those companies would pay for at this stage, and they’re usually looking for approachable and cost-effective solutions.
In both cases, if the ultimate decision-maker is probably the team manager, developers often influence the buying decision and are usually the ones nudging their manager to buy the product.
Segment 4: SMBs and Scale-Ups
This segment is pivotal for developer-first companies looking to amplify their revenue significantly. If you target SMBs and scale-ups, you would need around 10,000 clients, each willing to invest $10,000 or more annually. Unlike large corporations, SMBs and scale-ups are characterised by their agility and quicker decision-making processes. Their requirements, while complex, typically do not demand the extensive integration and customisation necessary for large enterprises. This segment is crucial for developer-first businesses due to their relative openness to adopting new technologies and the potential for rapid growth.
These companies often look for comprehensive solutions that include efficient development tools, scalable cloud services, advanced security measures, and robust analytics capabilities. They are in a growth phase, and reliable and scalable technological solutions can significantly impact their progress.
SMBs and scale-ups represent ideal clients for growing developer-first businesses. They are often at a stage where they recognise the value of investing in technology to scale their operations. Developer-first companies can provide these businesses with the tools and services they need to grow, establishing a symbiotic relationship where each party contributes to the other's success.
Segment 5: Large Enterprise Customers
The last stage of this journey for developer-first companies is to target large enterprise customers. To reach $100 million in revenue, you need 1,000 large enterprises spending $100,000 or more annually on your product. At this level, the buyers, along with their purchasing departments, are typically Chief Information Officers (CIOs) or Chief Technology Officers (CTOs). The complexity of challenges these enterprises face requires solutions that are robust, customisable and integrated. An example of a company successfully catering to this segment is Datadog, which provides comprehensive monitoring and analytics for large-scale cloud environments.
Large companies need comprehensive solutions that address a wider range of challenges and offer more advanced functionalities. This is where the solutions' complexity increases, meeting the demands of larger-scale operations. Products and services in this tier often include advanced security features, greater scalability options, extensive customisation capabilities, and in-depth analytics.
With substantial user bases or client lists, large companies’ needs extend to monitoring, operating, optimising, and securing their infrastructure. The scale of their operations necessitates solutions that ensure applications are not just functional but also fast, reliable, and secure. This high performance and reliability requirement drives these companies to invest significantly in developer tools and solutions.
However, engaging with larger companies involves navigating complex organisational structures and decision-making processes. The sales cycle is often elongated, requiring in-depth demonstrations, pilot programs, and discussions about integration and customisation. Success in this segment is not just about selling a product; it's about forming strategic partnerships, understanding the company's broader objectives, and aligning the product’s capabilities with its long-term technological and business goals.
One way to build a $100 million developer-first business
The journey to achieving $100 million in annual revenue for a developer-first business is multifaceted, requiring a strategic blend of different customer segments. Reaching this ambitious goal necessitates catering to a diverse array of clients—from individual developers and startups to SMBs and large enterprise customers. Each segment is crucial to building a robust, scalable, sustainable business model.
Central to this model is the provision of an exceptional developer experience. In today's tech-driven world, developers are increasingly influential in the decision-making process across all sizes of organisations. Even in large enterprises, adopting a new solution often starts with a single team or system. A positive experience in these smaller implementations can pave the way for broader organisational adoption. Therefore, ensuring that products are intuitive, efficient, and reliable is paramount. A great developer experience leads to higher satisfaction, stronger advocacy, and a greater likelihood of widespread adoption.
This model offers a pragmatic growth plan for developer-first startups, especially those in the early stages with limited resources. Initially, targeting professional developers and SMBs is a more feasible and less risky approach. These segments typically have shorter sales cycles and require less customisation and integration effort than large enterprise deals, which can be protracted and resource-intensive. As the startup grows in capabilities and resources, gradually shifting focus to include larger targets becomes viable and necessary.