Low-code/no-code: "Instant tea" or "hand-brewed coffee"?

Low-code/no-code platforms have become increasingly popular in recent years, claiming to enable non-professional developers to quickly build applications and even help professional developers improve efficiency. But does this mean traditional programming will be replaced? Are low-code/no-code platforms as convenient and fast as instant tea, or do they require the meticulous craftsmanship of hand-brewed coffee?

Core Concepts of Low-Code/No-Code

The primary goal of low-code and no-code platforms is to reduce the workload of manual coding by offering visual drag-and-drop interfaces, configurable options, and pre-built templates.

• Low-Code: Still requires some coding, suitable for users with technical backgrounds, such as enterprise IT departments or full-stack developers.
• No-Code: Requires no coding at all, ideal for business users or those with no programming knowledge, such as marketing or operations teams.

Typical low-code platforms include OutSystems and Mendix, while no-code tools include Bubble and Airtable.

Instant Tea: The Convenience of Low-Code/No-Code

The biggest advantage of low-code/no-code is rapid delivery. For example, a sales team wanting to build a customer management system can use Airtable to complete it in a few hours, whereas traditional development might take weeks.

Example: Building a Simple CRM with Airtable

// Example Airtable API call (assuming Base and Table are configured)
const Airtable = require('airtable');
const base = new Airtable({ apiKey: 'YOUR_API_KEY' }).base('appXXXXXXXXXXXXXX');

base('Customers').select({
    view: 'All Customers'
}).eachPage(function page(records, fetchNextPage) {
    records.forEach(function(record) {
        console.log('Customer:', record.get('Name'));
    });
    fetchNextPage();
});

This "instant tea" style of development is particularly suitable for:

• Internal tools (e.g., approval workflows, data dashboards)
• MVP (Minimum Viable Product) validation
• Non-core business systems (e.g., event registration pages)

Hand-Brewed Coffee: The Precision of Traditional Coding

While low-code is convenient, it often sacrifices flexibility and performance. For example, an e-commerce website built with Bubble might face performance bottlenecks during traffic spikes, whereas manual development with React or Vue can be optimized to the extreme.

Example: Traditional React E-Commerce Product List

import React, { useState, useEffect } from 'react';

function ProductList() {
    const [products, setProducts] = useState([]);

    useEffect(() => {
        fetch('/api/products')
            .then(res => res.json())
            .then(data => setProducts(data));
    }, []);

    return (
        <div className="product-grid">
            {products.map(product => (
                <div key={product.id} className="product-card">
                    <h3>{product.name}</h3>
                    <p>${product.price}</p>
                </div>
            ))}
        </div>
    );
}

Advantages of traditional development:

• Performance Optimization: On-demand loading, code splitting, SSR, etc.
• Customization: Full control over UI, interactions, and business logic.
• Scalability: Integration with any third-party libraries or services.

Limitations of Low-Code

1. Functional Ceiling: Complex business logic (e.g., real-time bidding systems) is hard to implement.
2. Vendor Lock-In: Dependency on the platform, with high migration costs.
3. Debugging Challenges: Black-box operations, troubleshooting relies on platform support.

For example, if an application built with OutSystems encounters performance issues, you might have to wait for official optimizations rather than directly modifying database queries or caching strategies as with traditional code.

Who Is Low-Code/No-Code Better Suited For?

• Non-technical Teams: E.g., HR using no-code to build a recruitment tracker.
• Rapid Prototyping: Product managers validating ideas.
• Internal Enterprise Tools: E.g., an equipment borrowing system for the admin department.

Traditional development is still needed for:

• High-performance applications (e.g., games, high-frequency trading).
• Deeply customized UI/UX (e.g., brand websites).
• Complex systems (e.g., microservices architecture, AI integration).

The Future: The Potential of Hybrid Models

Many companies are adopting a "hybrid development" approach, such as:

• Using no-code for backend admin pages.
• Using low-code to generate basic CRUD APIs.
• Keeping core business logic in handwritten code.

For example, a startup might use Bubble for an MVP, rewrite the frontend with Next.js as user numbers grow, and retain Airtable as a temporary database.

The Evolving Role of Developers

Low-code won’t replace developers but will change their roles:

• Traditional Developers: Focus more on complex architecture and performance optimization.
• Citizen Developers (business users): Can independently build simple applications.
• Low-Code Experts: Familiar with platform specifics, acting as bridges.

Just as baristas aren’t replaced by instant coffee but may need to learn how to operate fully automated machines.