The Dev World – Sergio Lema

Could the future of backend development be… no code at all? We’ve all seen the rise of no-code frontend tools, transforming web design from a coding marathon to a visual sprint. Yet, the backend often remains a fortress of endpoints, database schemas, and authentication flows, seemingly immune to the no-code revolution. Or is it?

Recently I’ve been playing a little bit about no-code tools to implement a backend. And the result was quite interesting.

The Backend Challenge: Beyond the Visual Drag-and-Drop

Building a robust backend traditionally involves grappling with server-side logic, data persistence, and security. While frontend tools like Webflow excel at abstracting away HTML and CSS, the backend’s inherent complexity—managing data relationships, handling user authentication, and orchestrating business logic—presents a different beast entirely. It’s not just about what you see; it’s about what happens behind the scenes.

Strapi and Supabase: Two Sides of the Same Coin?

When developers look for no-code or low-code backend solutions, Strapi and Supabase often come up. Both offer compelling features to accelerate development, but they approach the problem from slightly different angles.

Strapi: The Self-Hosted, Node.js Powerhouse

Strapi is a powerful, open-source headless CMS that allows you to build APIs quickly. It’s built on Node.js, and that’s key.

• Self-Hosted Flexibility: You have full control over your data and deployment environment. This can be a significant advantage for compliance or specific infrastructure requirements.
• Node.js Extensibility: This is where Strapi truly shines for developers. While it provides a fantastic no-code interface for content modeling and API generation, you’re not locked into a purely visual paradigm. Need a custom endpoint with complex logic? You can drop into the Node.js codebase and extend it as needed. It’s a Node.js application at its core, offering familiar territory for many developers.

// Example: extending a Strapi controller with custom logic
// This isn't strictly "no-code" but illustrates the escape hatch 
module.exports = { 
  async find(ctx) { 
    // Custom logic before fetching data 
    const data = await strapi.services.restaurant.find(ctx.query); 

    // Custom logic after fetching data 
    return data; 
  }, 
};

Supabase: The PostgreSQL-Powered Backend-as-a-Service

Supabase positions itself as an open-source Firebase alternative, leveraging PostgreSQL as its core database.

• Managed Services: Supabase handles the infrastructure, database management, and scaling for you. This means less operational overhead and more focus on development.
• Realtime Capabilities: Out-of-the-box real-time subscriptions are a huge draw for applications requiring live updates.
• PostgreSQL Goodness: For those comfortable with SQL, Supabase’s direct exposure to PostgreSQL is a big plus. You can interact with your database using standard SQL queries.
• Edge Functions: The Custom Code Caveat: Supabase offers “Edge Functions” for custom server-side logic. While these are a welcome addition, they can feel more restrictive than Strapi’s Node.js extensibility. Edge Functions are typically deployed as serverless functions, and while powerful for specific tasks, complex workflows can quickly become cumbersome to manage within this paradigm. They are, by design, more constrained in terms of environment and direct database access compared to a full-fledged Node.js application.

// Example: A simple Supabase Edge Function (TypeScript) 
// Limits the scope for complex interactions compared to a full Node.js app 
import { serve } from 'https://deno.land/std@0.170.0/http/server.ts'; 

serve(async (req) => { 
  const { name } = await req.json();
  return new Response(JSON.stringify({ 
      message: `Hello, ${name}!` 
    }), 
    { 
      headers: { 
        'Content-Type': 'application/json' 
      }, 
  }); 
});

The “Custom Code” Trapdoor: When No-Code Isn’t Enough

I know what you’re thinking about: but I need to add some custom code, it’s not just a CRUD backend what I need.

Both Strapi and Supabase offer fantastic starting points for no-code backend development. However, the true test of any such platform lies in its “escape hatch”—what happens when your requirements outgrow the visual interface?

For Strapi, that escape hatch is Node.js. You can extend controllers, services, and even plugins with custom code, effectively transforming your no-code setup into a highly customized Node.js application. This makes it a compelling choice for projects that might start simple but are expected to evolve significantly.

Supabase, while excellent for its managed services and real-time features, offers Edge Functions as its primary avenue for custom logic. While powerful for specific serverless tasks, they don’t provide the same level of deep integration and extensibility as directly coding within a Node.js application like Strapi. For truly bespoke backend logic that requires tight coupling with your database or complex external integrations, you might find yourself hitting limitations faster.

The Developer’s Verdict: No-Code as a Launchpad

The “no-code backend” isn’t about eliminating code entirely. It’s about radically accelerating the initial setup and common functionalities. For developers, tools like Strapi and Supabase act as powerful launchpads, handling the boilerplate and allowing you to focus on the unique challenges of your application.

Which solution did I chose? Strapi? Supabase? Or another custom backend?

In fact, I’ve taken the three solutions. For a project (quite complicated project), I’ve setup a Strapi backend to have full control over the backend but start quickly, very quickly.

For another project, I’ve created a simple Supabase backend. It didn’t need quite a lot of logic, a simple CRUD was enough.

But when I do really need a lot of customization and performance, an old custom backend is always my choice.