No-code, scalability, and how it all works – with the right stack

I’ll be frank, this is a common concern among most aspiring no code devs or those looking into using a no-code solution. It’s no wonder, really: with most no-code platforms, you can usually do just one thing really well, and depend on something else to scale. Is it even possible in the first place?

Yes.

I’ll tell you this here and now: no-code platforms can be used for any product stage, including a late one. You just need to pick your platform and third-party systems well (if you need them). Takes a bit of know-how and experimentation, of course, but it pays not to jump to conclusions before you see the whole picture of what scalability truly is. 

What makes no code scalable?

“Scaling” in its true sense depends on a variety of factors: 

• The app’s end functionality
• How the app is tested
• How the server infrastructure holds up
• Integration capabilities

Of course if you ever reach the size of Twitter or Google, something more sustainable might be required, but it will be a nice problem to have. 

The main bottleneck a lot of no-code platforms face is data exchange speed, which is why some of them might seem unresponsive or take forever to process requests. Yet, you have to reach a truly staggering amount of transactions happening for this to occur. 

The other roadblock to scaling is not related to app builders but is rather a general misunderstanding of what no code is, and the novelty of it all. Platforms chase against the ever-shifting demand and evolving tech, and us mere mortals try to keep up and build at the same time.

The biggest indicator of the scalability of no-code platforms is…the no-code platforms themselves. Bubble, Zapier, and even our own platform pretty much are built upon their own functionality. 

What is truly needed for a scalable, confident product built on a no-code platform, is knowing the right tech stack and trying things out first before making a judgment.

A case where no code didn’t seem to work

Recently an informative post was made by FINN, a German car subscription service that started its journey with the help of a no-code platform. FINN had explosive growth, and naturally with that came a number of challenges, which proved too much with their tech stack at the time.

When I say explosive growth, I mean it: in just one year, they’ve managed to go to 4 Mn € ARR and grow from 0 to 20,000 subscriptions. That’s no small feat, which is why this case is so exciting to analyze.

FINN used Airtable, Make, and Retool among other tools in the tech stack in order to build the infrastructure, automation, and other support systems. Naturally, it proves that no code tools were fantastic for the first stage of their product journey. Of course, troubles came knocking once the growth became truly through the roof, to name a few:

• Airtable databases weren’t up to speed (up to 100 timeouts a day)
• Data coupling (due to one large database with 20 tables, one of which had nearly 400 fields)
• Control process access limitations
• Tough testing processes
• Synchronization issues and lag due a lot of automation and data exchange

After that conundrum unfolding and at the eve of expanding to the US market, FINN made a decision to resort to traditional coding, and start from scratch. The migration process is still ongoing, it’s going to take a while, but with the right approach, of course eventually it’s going to be completely okay.

However, this entire problem occurred primarily due to the wrong stack of tools. And here’s a little proof of that.

A case where no code worked like a charm

One of our clients, Karma (a global p2P loan platform) follows along a path similar to FINN: explosive growth, complex product, tons of automation, and tackling new markets.

Except for one little difference: there is no need to migrate an entire infrastructure to a dev team to build it from the ground up because it already scales well enough. But what could be the secret?

The right tech stack. 

Karma’s journey has been, in a way, the opposite when it comes to development: they’ve started with a dev team that took too long to prepare necessary systems, was too expensive, and is much less agile. There is a common element between these two cases, however: Bubble! But only for front-end purposes, because I’m not afraid to say it: Bubble’s front-end templates do look rather gorgeous.

Now, Karma is on its way to success, scaling to any limit they need with ease, with Directual’s heavy back-end capabilities doing the heavy lifting. Database hiccups? Nope. Synchronization lag? Nothing. It just works! 

Afterword

If you’ve got your eyebrows raised at this very moment, it’s okay. Karma is not a carbon copy of FINN’s business model, or approach. The takeaway here is incredibly simple: no code/low code platforms can easily scale with the product, so long as vet them first. 

With the proper tech stack and continuous evolution of no-code app builders, this is becoming the way to develop new products, regardless of size or load. It’s faster, significantly cheaper, and has a much lesser learning curve. The no-code movement is growing to its size for a reason.

The best path is to combine the best of both worlds: no code’s flexibility and speed with the best development practices of traditional coding. You can achieve much more with less if you’re brave to try new things.

Reach for the stars, with the right tech stack in hand! 

In case you’d like to know how it all works with our platform, shoot us a message to hello@directual.com.