No-Code Doesn't Scale, and Why it Doesn't Matter

By: Korey MacDougall Published: 2022-05-25 Last Updated: 2022-05-27

Summary - In this article we explore why “scale” is the wrong thing to be worried about when building your NoCode venture.


Technology Entrepreneurship is Changing

Technology entrepreneurship is a radically important, arguably fundamental, component of modern civilization. In the last 50 years, technology entrepreneurs and the companies they’ve built have remade the world; everything from entertainment to finance, education to romance. There are few paths to societal impact and personal wealth as promising as high-tech entrepreneurship.

Until very recently, this path has been available to only a small group of people: those with the ability and inclination to spend weeks, months, and years punching sequences of symbols into a computer (i.e., computer programmers), and those who could partner with them on translating a vision into reality. No-Code and Low-Code (NC/LC) platforms are changing this. Tools like Bubble, AppGyver, WebFlow, Adalo, and many others, are enabling folks without a computer science degree, years of computer programming experience, or an affinity for dark-mode terminals to turn their ideas, experience, and passions into businesses. This has the potential to be absolutely transformative for the internet, the technology landscape, the practice of business, and perhaps most concretely/importantly, the lives of No-Code/Low-Code entrepreneurs and their customers.

Starting an online business can be a path to autonomy, purpose, impact, and fulfillment. It can be absolutely life transforming. And NC/LC platforms are making this path accessible to many, many more people. I predict that NC/LC tools will prove to be one of the most important trends in technology in the remainder of this decade.

But despite the hysterically positive rhetoric (ahem), there remain some nagging doubts and lingering issues. Because these tools are so new, and the rules of engagement for NC/LC entrepreneurship have yet to be fully formulated, some individuals are hesitant to throw in their lot with the NC/LC platforms. There is a fear that building your startup, side-hustle, or small business with No-Code/Low-Code is a risky long-term move. Some of the most common concerns I’ve seen include:

  • Does No-Code scale?
  • What about vendor lock-in?
  • Will we be able to raise money from VCs?
  • Can you build more than an MVP on these platforms?
  • Could I ever sell a company that I’ve built with No-Code or Low-Code?

These questions are all valid concerns, and each probably deserves its own article. In the remainder of this post, I will try to explain why I think the first question, “Does No-Code scale?”, is the wrong question to ask for almost everyone.

No, No-Code Doesn’t Scale

In consulting with entrepreneurs, businesses, and makers looking to build some new business or tool using NC/LC, I have been asked many times: “Does no-code scale”? If the question is taken at face value, the answer is “No, no-code doesn’t scale”. The currently available platforms, in their present forms, are not yet mature enough to build technology products or companies at the level of Google, Twitter, Uber, or Facebook, with billions of users, uninterrupted global presence, multi-warehouse data scale, etc. Similarly, you will also not be able to build space shuttle guidance systems, pacemakers and other embedded devices, or the brains of an autonomous vehicle. There are currently too many missing pieces:

  • sophisticated version control (e.g., git),
  • advanced collaboration systems and practices (e.g., branching pull-request-based workflows),
  • reliable continuous integration / continuous deployment (CI/CD) tools (e.g., Jenkins, GitHub Actions),
  • a catalogue of battle-tested best practices and design patterns to draw on for solving complex, recurring problems (e.g., the OG design patterns book Design Patterns: Elements of Reusable Object-Oriented Software ,
  • a deep pool of talented engineers and designers familiar with the platforms (along with supporting training programs, career paths, etc.),
  • an ecosystem of interconnected tools and communities (e.g., npm for nodejs, the Python community, or the globally dispersed chapters of the Google Developer’s Group)
  • etc.

Software development or software engineering has been evolving as a distinct craft and trade for about for about a half-century (born in 1968 by some estimates, e.g. this paper by Northover et al.. No-Code has a bit of catching up to do, though of course NC/LC are not “new” or starting from scratch. They are instead abstraction layers on top of software engineering. In those 50-odd years, we’ve collectively learned quite a lot about what it takes to build great software products. Some of that has been distilled into books, university programs, video courses, bootcamps, and training communities. Other bits have become digitally embodied in tools, such as those for CI/CD, version control, testing automation, and usability analytics. Still others are embodied in the high-level, abstract wisdom, snippets, parables, and paradigms we use when thinking about our efforts at building software: “disruptive technology”, “insanely great”, “software craftsmanship”, “distributed systems”, “microservices”, “user-centered design”, “accessibility and inclusivity”, “99.99% uptime”, and on and on. And finally, some of that knowledge has been encoded into low-code/no-code tools, which translate the common needs of web developers, like UI construction, sign-up and login flows, database connections, and payment integrations, into a set of pre-built components and a simplified graphical construction interface (i.e., a GUI).

The no-code low-code space is still young, and its guiding principles, best practices, toolchains, ecosystems, and communities of practice and influence are only beginning to emerge. It is an exciting time to be part of this emerging space, and there is a wonderful opportunity to be involved in shaping a force that is poised to become increasingly important over the next 5-10 years.

The flipside of that possibility is that No-Code isn’t yet ready to go toe-to-toe with modern software engineering; it has some maturing to do. But for the vast majority of folks that are considering NC/LC for their next venture, this does not matter. Pitting software engineering against no-code/low-code is, I think, the wrong frame of mind, the wrong way to think about the problem, and leads to questions and answers that don’t serve. I’ll explain below why I think No-Code/Low-Code tools are a good option in many cases, and why entrepreneurs need not worry that building on NC/LC will prevent them from serving their prospective customers (spoiler: it won’t).

Why it doesn’t Matter

What is important to recognize, for our purposes here, is that software engineering is a wide ranging field, covering everything from manufacturing to healthcare, robotics to video games, data science to point-of-sale terminals. Not all of the pieces of the culture, climate, and practice of software engineering are relevant when thinking about No-Code/Low-Code. In particular, the notion of “scale” is a dangerous and misleading concept. The mythology of “startups” today is something like: “small group of smart, ambitious founders see a novel solution to an important problem, build a prototype in a garage via caffeine and all-nighters, raise millions, scale massively, change the world”. Scale is a critically important piece of this narrative:

  • It means raising VC money, because (as everyone knows…), investors want to see massive returns (like 100x), and are basically gambling on your disproportionate success, so if you can’t scale, you likely can’t raise.
  • It means changing the world, because only with a huge userbase can you make a dent in the universe. And it means importance, relevance, esteem (self and otherwise).
  • It means unbounded growth, technological sophistication, the best engineers, power, profit, and all the other perks parodied so adeptly by HBO’s Silicon Valley.

In short, scale is a muddy concept that roughly equates to success in the modern myth of the technology entrepreneur. So if you are ambitious (the story goes), you ought to be thinking about scale. And so when potential clients ask me if Bubble or WebFlow will scale, what they really want to know is: am I hurting my chances of succeeding as an entrepreneur by adopting No-Code/Low-Code over traditional software development tools? And this is an incredibly important question. There are about a million alligators in the pit of entrepreneurial doom, waiting to bite your legs off. So reducing/managing risk is one of the most important things you need to do as an entrepreneur. But for almost every entrepreneur or maker I’ve worked with, talked to, or read about, scale is not one of the alligators in their pit. It’s a phantom worry. It is much more likely that your success will be hampered by things like: not selecting the right niche, not solving the right problem, not managing expenses well, not pricing properly, making hiring mistakes, etc. Incidentally, a couple of great books on these topics for folks who might be considering an indie startup or side-hustle using no-code/low-code are Zero to Sold by Arvid Kahl, and Company of One by Paul Jarvis. While they are not aimed specifically at NC/LC founders, most of the practical wisdom applies just as well to NC/LC ventures.

Almost no business ever reaches “scale”. And that’s okay. You can build a wildly successful business with a few dozen or a few hundred customers. You can build a 7-figure business with 1000 customers paying $99/month. I’ll say it again: for almost everyone, scale doesn’t matter. If you are thinking about a new business idea, or a new product launch, you’re almost certainly better served by thinking about how to reach more prospective customers than about whether you’ll be able to serve the needs of the millions that flock to your new offering.

That being said, the question of whether No-Code scales offers some interesting food for thought if you break the question down. “Scale” can refer to many different aspects of a software business. In the next few sections, I’ll break down what I think are the main components of scale, and how no-code/low-code measures up in these dimensions.

A caveat before we get into the breakdown. The question of scale isnt’t binary. It’s not the case that something can either scale or it can’t. It is a progressive, quantitative question. Scaling to 1000 users is very different from scaling to 1 million or 1 billion users. To properly ask the question, we’d need to parameterize everything from userbase size to load times, and to answer it, we’d need to run quantitative tests. As far as I know, such analyses have not yet been run (at least not publicly; perhaps the NC/LC vendors are doing such load testing internally). If you happen to know of some quantitative data on this topic, please reach out and let me know! I’d love to read it.

Scaling users or traffic

This aspect of scale is perhaps the most common bit of what people mean by scale. It can be further broken down into components of application performance, and can be rephrased as something like:

“Can our database / servers/ CDN / etc. handle 1 million+ simultaneous visitors?”

It is a question about performance, availability, and resilience, and about the technology underlying your application, website, or service. The answer to this question depends on the design of your system and how it is implemented. In short, the question is about whether your “stack”, or selection of technologies, can handle a high volume of use and users, and remain performant (i.e, your UI remains snappy/responsive with low load times, the app doesn’t crash or become unresponsive under heavy load, databases don’t lock up, etc.).

Can modern no-code/low-code development “scale” in terms of users? I.e., can apps built with these tools support a lot of traffic? The answer is: yes, probably. These platforms are built atop the best available tools: infrastructure providers like AWS, javascript frameworks like ReactJS, and databases like PostgreSQL and Firebase. So in theory, the apps built on these NC/LC platforms should be able to scale exceptionally well. In fact, I’d argue that for most developers, you are likely to get a more performant, scalable app by building on NC/LC than by building something yourself, because so much of what we know about best practices for building scalable web apps has been abstracted behind the NC/LC interfaces.

But this is at the theoretical level. In practice, things are more complicated, naturally. Because these NC/LC platforms are largely commercial endeavors (though some open-source tools are starting to emerge), there tend to be application limits based on pricing tier. Certain limits tend come baked into each tier, such as the following:

  • maximum number of allowed active users,
  • maximum number of database records,
  • file storage limits,
  • compute limits (how much server / processing time you are permitted)
  • etc.

So in theory, apps built on the major NC/LC platforms should be able to scale indefinitely, just as if they were built cloud-native. In practice, however, this may mean that you need to subscribe to an expensive tier, and your app may cost substantially more to run than if it were built with a traditional software stack. And in some instances, there may be hard limits that you can’t pay your way past.

But, again, the devil is in the details: you can’t simply compare monthly operating costs between traditional software stacks and no-code/low-code stacks. At least as important, and more so for many ventures, is the cost of getting to market, or getting to sustainability. In other words, how much will it cost you, in terms of time and cash, to get your minimum viable product (MVP) in the hands of your first paying customers, or to get your app/business to be self-sufficient/profitable? No-code/low-code tends to be much faster for developing early stage products, and this can mean the difference between running out of cash and moving on to the next project/business/job, or quickly getting a handful of customers that justify the effort and expense and tell you that you’re on the right path, which will provide motivation, revenue, and momentum, and can help you create a flywheel of growth that leads to a great business.

For many types of web applications, the limits of no-code/low-platforms are well within acceptable bounds, and users are not likely to balk that your app isn’t “performant” enough, even under substantial load. And in terms of sheer horsepower, NC/LC tools are bound to get better in the coming years. We are also likely to see more flexible platforms arise, that allow modular replacement to get around application-specific limitations. Bubble, for example, already makes it fairly simple to use your own database, integrate third party services (via its API connector), or embed custom mini-apps into your app (built and hosted on whatever stack you like), and I suspect as the ecosystem evolves, such interoperability will become the norm (think Zapier on steroids).

In summary:

Does No-Code Scale in Performance? Yes, with qualifications.

Scaling Revenue

A second aspect of scale that is of prime importance to many entrepreneurs and aspiring founders is whether a business built on no-code/low-code can scale its revenue. The answer here is a simple yes. There is nothing inherent in these platforms that would limit your potential revenue. Though examples of 7+ figure businesses are not yet abundant and visible, as the space is still emerging, there are examples of folks who’ve shared their story about building million-dollar no-code businesses. A great example is Jordan Richardson, who has shared his story on Twitter as @NoCodeAdvantage. (If you are such a founder, and would be interested in sharing your story, or have shared it elsewhere, please reach out! I’d love to chat).

To be thorough, it’s probably worth addressing the unicorn question: “can I build a billion dollar startup with No-Code?“. That, I believe, remains to be seen. To the best of my knowledge, this has not yet been done. I don’t think there is anything inherent in the platforms that would stop someone from doing so. But again, this is almost certainly the wrong question for almost everyone. Only some vanishingly small percentage point of companies ever become billion dollar companies. And none of them got there with their first build. In other words, it’ll be years and lots of rewrites before you hit 10 figures. So don’t waste time wondering asking the billion dollar question.

In summary:

Does No-Code Scale in Revenue? Yes.

Scaling A Business or A Team

Another aspect of scale that entrepreneurs often wonder about is growing their team or their company. Some people start businesses because they have a vision that is unachievable alone. They embrace the challenge of building a team of like-minded individuals to work hard together on an important problem. Some even aspire to building a high-performing team that can compete in the global arena in a big, competitive market.

Such entrepreneurs may ask whether it is possible to build a company or a startup around No-Code/Low-Code. And here, I think, is where we get our first “no”, or at least “probably not”. The primary reason for this, I would argue, is that the tools around the no-code/low-code platforms are not yet well-enough developed. The NC/LC platforms are becoming very capable, very quickly, but the tools to embed the platforms within a larger org or development project are lagging behind.

To date, it is hard to use No-Code in teams larger than a handful of people, because the supporting tooling for things like version control, CI/CD, automated testing, ticket management, etc., are not yet up to snuff. In contrast, traditional software development teams have plenty of great tools to help manage complex development projects:

  • Jira - management of work, time, release schedule. Scheduling and co-ordinating.
  • Figma - collaborative design tool, shrinking the gap between designer and dev.
  • Adobe Suite - For marketing + ops interops.
  • Git and GitHub - handle version control, past-present-future tense, multi-team
  • Mural - online whiteboarding
  • etc.

These interop tools are like the whitematter of the organizational brain: they allow the multiplication of expertise over domains, according to some non-linear function, i.e., a "greater than the sum of its parts" combination of the skills of the various departments and teams.

For some comic relief, note that this multiplicative function may not be simple and ever increasing. See, e.g., [Fred Brooks' The Mythical Man Month](, for a tragi-comic look at why the curve may be parabolic when plotting team size to productivity.

Because of the relative immaturity of the supporting ecosystem in the No-Code/Low-Code space, if a founder expects they will need to build a complex company, one defined by the division of labour among a group of multi-disciplinary experts, No-Code is probably not yet the right toolkit.

This doesn’t mean that No-Code/Low-Code would have no place in such a company, or that it’s categorically impossible to scale a no-code company. It may be the case that fast-growing, complex companies can benefit from using no-code/low-code tools or automation platforms in some part of their product development or service delivery, and perhaps NC/LC can complement more traditional tech stacks in other parts of the company. Furthermore, given the immense interest in the NoCode/Low-Code space lately, I think we will continue to see these companies make great improvements to their platforms, and an ecosystem of supporting tooling emerging quickly. Soon enough, we will probably be over the NC/LC interop hindrance.

But I think the original point stands: as of today, it would be difficult to significantly scale a technology company using only no-code/low-code tools.

In summary:

Does No-Code Scale with respect to company size? Probably not (yet). .


No-Code probably doesn’t (yet) scale indefinitely. But for most entrepreneurs and makers this doesn’t matter. NC/LC platforms are incredible tools for building products and businesses. You can build things far quicker and cheaper than you typically can with traditional software, and you can change lives doing it, including your own. You’re not going to build the next Google with Bubble or WebFlow, but Google’s already taken anyway. Build your own thing, and have a blast doing it.