The Next Billion Developers

Roughly a month ago, GitHub reached its 2025 target of hosting 100 million developers on its platform. The goal was set in 2019 when the platform had 40 million developers worldwide.

Their underestimation highlights the staggering developer growth over the last few years. With this growth has come an increasing interest in tooling for developers. As a result, early-stage developer tool companies received over $4.4 billion in funding in Q4 of 2022, nearly triple the amount invested in Q4 of 2019.

Although the growth in developer tooling is impressive, many criticize it for only empowering a small fraction (<1.5%) of the world's population to create software. "No-code" tooling emerged to fill this hole and enable non-developers to build software applications.

No-code is a software development process that enables programmers and non-programmers to create software applications using a UI (user interface) without requiring manual coding. 

The idea itself is not new, but the number of software creation tools classified as "no-code" has grown significantly over the past five years. Notable examples include Webflow, Airtable, Bubble, Retool, Notion, and Amazon's Honeycode. 

The popularity of no-code tools has resulted in a differentiation between software creation tools geared toward developers and those catering to non-developers.

Although "no-code" may suggest the opposite of developer tools, these tools have more similarities than differences.

They both take developers of varying proficiency and allow them to create their software. 

In fact, if you step back and look at it:

No-code and developer tools are the same thing — they just provide different levels of accessibility to their users and offer varying levels of extensibility. 

In software, extensibility refers to the ability to add new capabilities or functions, just like how Lego bricks allow building on top of existing models, while other toys would require buying a different one.

React vs. Webflow

Let us take React as an example. React is a developer framework for building user interfaces. It’s built on top of JavaScript and is one of the most popular web frameworks among developers today. 

This is what React looks like:

React is incredibly extensible. Users can write their own components (which act like Lego) and completely control how they are shown in the browser. They can define their styling and layout within React or separately. 

On the no-code side, let's look at Webflow. Webflow markets itself as a no-code website builder. It gives users a visual editor (shown below) to style and lay out their web pages. Internally, it uses HTML and CSS (like React) to lay out these pages, but it hides much of that complexity from users in favor of a more accessible experience.

If you asked me to build, say... Twitter, I'd be hard-pressed to choose Webflow. I'd need to make custom file storage, direct messaging, and many more features that this "no-code" tool doesn't support. Simply put: the project would require significantly more extensibility than Webflow offers. React would be a much better choice.

For a basic web page, both Webflow and React can be used. However, even as a developer, I'd pick Webflow. Its visual layout system is faster than messing with CSS, and I can deploy it within the tool. I could have a website up in under 10 minutes.

My point here is to illustrate that there are use cases in which less complexity is preferred, even for developers. 

Accessibility or Extensibility

Looking at all the tools available to build software, we can begin to organize them by extensibility. 

We can establish a partial ordering among these tools by defining that a tool is more "extensible" than another if it has the capability to create the latter.

In our example, we'd say that React is more extensible than Webflow because we can build Webflow with React, but not the other way around.

Applying this to some commonly used tools, we get something like the following:

At the top, we have C. C is a general-purpose programming language that underlies a lot of technology we use today. Virtually any project can be built using C, but even seasoned programmers avoid C (unless absolutely necessary) because of its complexity. 

The following two levels (JavaScript, AWS, React, NodeJS, Vercel) are typical "developer tools". These tools are often built in more complex languages like C; offering programmers increased ease and the requisite flexibility to do most work. 

Traditional 'no-code' tools (Retool, Webflow, Airtable, Notion) are at the bottom. Although they are the most accessible, they are also the least extensible. These tools are often marketed towards non-coders, but even developers can benefit from their specialized user interfaces, which can provide the fastest solution to modest problems.

At each level, we trade extensibility for accessibility. To make things easier for users, it seems inevitable that we shrink the universe of problems these tools can solve. 

Is this always the case? Are there tools that offer both high accessibility and high extensibility? 

A tool that grows with you

Imagine a tool that's user-friendly enough for anyone, even your parents, and also robust enough to meet the needs of industry professionals. Although it may seem like an impossible balance to achieve, you are already using a tool like this: spreadsheets.

Spreadsheets are a prime example of high accessibility AND extensibility. They have a simple yet powerful interface that can be used for anything from a grocery list to a complex financial model. Spreadsheets are used by over a billion people worldwide, including both lay and expert users. They provide complexity to those with advanced knowledge while remaining user-friendly and extensible for everyone.

While they aren't new, spreadsheets showcase what's possible with a tool. They show us that it's possible to build something radically accessible with high extensibility. They show us that a user can define the tool rather than the tool defining the user.

The spreadsheets of developer tools doesn’t exist at the moment, and I doubt it will exist until we re-examine how we develop today. Were HTML and CSS designed to be accessible to everyone? Perhaps in 1996, but today I know plenty of professional developers that would say it wasn’t even designed for them. We can now build a similarly extensible alternative that’s far easier to use. 

Yes, the future development environment does look closer to Webflow than VS Code, but we can’t get there by shunting extensibility. A tool must be built for both developers AND no-coders. Otherwise, we will not bridge the gap and will be left with tools for creating landing pages rather than creating software.

As we aspire to a world where over 2% of the population is creating software, we need tools that allow more people to do more. Spreadsheets showed people rows and columns and taught billions how to program (via formulas). Today, we have a similar opportunity with developer tools to give users visual builders that can teach them how to build software.

An opportunity to make experts rather than simply catering to them.

---

Thanks for reading! This is part of our vision with Pax. We’re building a developer tool that will natively support non-coders. Please reach out if you want to chat about it.