We’re really excited to have Karthik Sridharan share his journey with us on today’s Featured Story. His experience with building a successful business on using a few simple no-code tools is nothing short of inspiring. In this blog, he shares three important lessons from his journey that will help any entrepreneur or aspiring maker think through their business model.

Here’s his story!

Hi, I’m Karthik Sridharan! I'm the co-founder and CEO of Flexiple.

It's been about five years since we launched, and I’m here to share the convoluted, unpredictable journey I took to get into entrepreneurship.

An important part of our journey, other than the fact that we still use no-code, is the fact that we are bootstrapped. We've been bootstrapping this business from the beginning, and have moved from strength to strength.

In the last year and a half, we've grown about 5x. We just hit $3 million in revenue earlier this year. And now we're working to build a good solid team around us that can possibly help us meet all the dreams and ambitions that we have laid out.

Joining India’s most prestigious business school

I studied engineering – electrical engineering to be specific. But like many engineers in India especially, I decided on a career in finance and joined investment banking, as an analyst in one of the ‘Big Four’ financial firms.

I worked for a couple of years in India, and then moved to London for work.

Like with any job in finance, the demand on your time and effort is extremely high. I was okay with that, but I wasn’t okay putting so much in for something I wasn’t passionate about. The hours, the effort – it didn’t feel like it had any impact at all.

I decided to quit it and do an MBA, thinking it would give me the space to decide what I could do next.

I got into the best business school in India, called IIM-Ahmedabad. In my first week, I was amazed at how the focus of the entire program was just about getting a job. The discussions were all centered around interviews, CVs, internships – not running a business or entrepreneurship.

I decided to bypass the entire placement program, which is a big deal because it’s the main reason people join this business school in the first place. That was my entry into entrepreneurship!

Connecting tech companies and freelance talent on Flexiple

I managed to convince two of my batch mates to join me in this journey, and they also quit their placements. The three of us joined forces to build Flexiple.

We had begun to see a shift in the talent market – we realized that high-quality talent wanted more flexibility associated with their careers. Freelancing, coupled with the trend of working remotely was already growing in a big, big way.

Of course, the last couple of years have accelerated a lot of what we expected, but this was something we’d been betting on half a decade ago!

In the freelance market, there were already platforms like Upwork and Fiverr, but for some reason, they came with the assumption that you're low-quality or provide unreliable services.

We wanted to solve this perception problem by adding a layer of vetting to create a truly high-quality network. One that could give both freelancers and clients the confidence that they’d have really fruitful interactions with skilled, high-quality and reliable people.

Especially with the startup ecosystem booming across the world, where startups want to scale their teams really quickly, we believed a solution like ours would be really helpful.

Unlike the permanent job market – where startups might have to wait from three to six months to hire each person and add them to their team – on Flexiple, they could find and hire within a week or two.

This ensures that they're able to build their product much quicker, with less time spent on hiring, and more on refining their product.

As far as industries go, we realized that the tech industry in particular, had the biggest hiring gaps and needs.

Because of this, we focused on building a freelancer network of developers and designers. The nature of these two job profiles also aligned with remote working, and tools made it easy for teams to work well asynchronously.

So Flexiple connected reliable companies with high-quality talent, where freelancers didn’t have to constantly market themselves, and companies didn’t run the risk of hiring talent that wouldn’t achieve their goals.

Using no-code to reduce Flexiple’s bottlenecks

To get started, we built an exclusive tech talent network, where we’d evaluate freelance developers and designers before they joined the networks. Then, we’d connect these talented individuals with tech startups and companies all across the world.

We made the mistake of making a very extensive, complex product in code initially and then recognized that people didn't really want to use it so much.

So instead, we began to focus on building the business.

For our business, we got the first $100,000 just by using Google Sheets! We had two sheets, one called ‘Companies’ and other, ‘Freelancers’. We used to talk to them, note down their names and details, and then manually match companies to freelancers, send them emails, make invoices and so on.

From wanting to make a very scalable product, we instead ended up with something very manual, because as I said, we decided to focus on the ‘business’ and not the product. But when these processes began getting too tedious, we decided to use no-code wherever we faced manual bottlenecks.

It started with just a little bit of automation.

We started with Airtable and Zapier, so we could collect data and move it into our CRM to trigger emails to our freelancers. This is where my no-code journey began!

But as we kept going, we started facing even more bottlenecks, especially as the scale of what we wanted to achieve was increasing.

This time, instead of committing to build a product, I just started extending our no-code stack. So we added Webflow to our stack, and freelancers would login through Memberstack and express an interest in any of the projects on our database.

It wasn’t long until the entire stack became very, very complex.

Connecting our no-code tools

So it was Airtable, Zapier, which then moved to Integromat and then Memberstack.

There were so many touch points, which resulted in things breaking here and there. That’s when I decided to move us to Bubble so that all of this could be under one roof.

We kept Airtable because of its great data visualization tools, and we have a bunch of scripts on it to shortlist freelancers.

Along with this, we also built a bunch of side projects. One is called Scale, which helps developers, designers and entrepreneurs access high-quality illustrations. These are open-source. You can actually change the colors of the illustrations with a color picker, and add things on, like a COVID mask for example.

All of this has been done on no-code, with a bit of code added on top of it. It’s all on Webflow.

We have a few more no-code projects and the entire stack is very, very affordable. It still costs less than $100 a month and we're able to pull in a revenue of over $3 million.

It got a little complex, as I said earlier, because we had four tools interacting with one another: Airtable, Integromat, Memberstack, and Webflow. Most of the connections between Bubble and Airtable are made through API calls.

Bubble has API workflows and we’ve written scripts for Airtable which make API calls so that’s how we’re operating things right now. Scale, like I mentioned, is entirely on Webflow.

Lesson #1: Scalability shouldn’t always be the priority

There’s a lot of talk, especially in the startup ecosystem, about the constraints of no-code and the issues with scalability.

In my opinion, you just need to embrace it. In fact, sometimes those constraints are a blessing in disguise, especially for companies in the early days of their launch. When you have no constraints, you begin to focus on the wrong things – what color should this button be, what animations should we add.

And in the process, you lose sight of what you're actually trying to build. You forget that your one job is to ensure that the solution you're offering to your customers is top-notch.

No-code, with its constraints, pushes you to focus on that.

If there are things that I still want to implement in some other fashion, I write a bit of code, whether it's simple HTML, CSS, or even some JavaScript. Maybe in the future, we might consider shifting to a code-driven environment; we aren’t averse to it.

Focusing on scale too early, before you’ve worked on your product and business model is detrimental. I think the challenges we faced taught us some important lessons.

Eventually we also had to learn our way through marketing, SEO, and promotions. We were overly reliant on Product Hunt, but recognized that it shouldn't be how we grew our business. We started being much more active on Twitter, LinkedIn, and on relevant communities other than just ProductHunt. We went from a website that got about 4000 visits a month, to now scaling that to 100x, with between 300-350k monthly visits.

It's been a journey – a slow and steady one!

Lesson #2: Think business model before tech

We made two products, spending about $5,000 each on them, and eventually had to junk them both. I took a good six months out of our timeline building those products, so that wasn’t productive, but I guess I learnt a lot.

My main lesson was that tech is not everything! It’s always business before tech. Always build a solution that

(i) your customers want, and

(ii) that works!

Then use tech to scale that particular solution. Don't start the other way. Don't build products that can scale and then test whether it actually solves the problem that you were initially trying to solve.

That's what pushed us towards no-code, from initially using Google Sheets, and then Airtable. No-code actually makes you think along those lines, which is business before tech.

Tech is just a means to an end. It can end up just being fancy talk that makes you sound very intelligent in the market, but you can often miss what customers really want.

I think a lot of the buzzwords these days around blockchain, AI and ML, etc. are, in fact, just buzzwords. No customer cares about them. They care about how you're solving their problem.

Lesson #3: Rome wasn’t built in a day! Start simple

The entire concept of MVP is great! The idea is to build a product in its simplest form to get early validation, rather than trying to build something extensive. We all interact with really high-quality websites and apps everyday. You use Uber, Airbnb, and you think ‘Okay, my first version of the product needs to be that good.’

It’s inspiring, but I think that’s the wrong approach! Those solutions have evolved over years to become that good. Using Flexiple as an example, our first product was just on Google Sheets. Once you’ve got that in place, you should focus on marketing and distribution. Don't let that be an afterthought.

SEO is great! Don't think of it as a traditional way of marketing – it's very relevant even today.

Find a few different marketing channels that work for you and invest in them. Just relying on word of mouth is a prayer. Great products don't bring customers by themselves; you need to bring customers to you. Then comes word of mouth, which is generated over time.

More than anything else, I'd call this entire journey a pursuit of happiness. I wasn't happy doing my job as a financial analyst. I wasn't happy with the way things were at my MBA school. I finally found happiness in what I'm doing at Flexiple and in entrepreneurship in general.

So that's my journey! I hope these learnings help you!

I’d encourage any designer reading this to check out Scale. It’s completely open-source and free.

Here’s an article I wrote about my experience with no-code tools, and if you’d like to know more about my work, you can find me on Twitter here.


What's your story?  Tell us how you use no-code
Something wrong?