DEV Community: Aman Suryavanshi

Why I Chose n8n Over Zapier for Production Lead Automation (₹0 vs $828+/Year)

Aman Suryavanshi — Thu, 23 Apr 2026 18:07:54 +0000

Why I Chose n8n Over Zapier for Production (₹0 vs $828+/year)

TL;DR:

Built production lead automation for an aviation training school: 3 workflows, 28+ nodes, 50+ leads/month, 99.7% reliability
n8n software cost: ₹0 forever. Zapier would charge $828+/year (and scale exponentially)
Code flexibility was the dealbreaker: one JavaScript node vs 6-7 separate Zapier steps for the same validation logic

The Problem

I needed to build a lead automation system handling real revenue with near-zero failure tolerance. The budget for automation tooling was as close to ₹0 as possible.

The client was Aviators Training Centre, a real aviation training school generating ₹3,00,000+ in revenue. The requirements were non-negotiable:

3 interconnected workflows (lead capture → booking management → cancellation recovery)
28+ automation nodes across all workflows
Custom JavaScript validation logic to catch empty webhook payloads
Near-zero tolerance for silent failures (real leads = real revenue)
Client budget: as close to ₹0 as possible

Two platforms made the shortlist: Zapier (9,000+ integrations, mainstream choice) and n8n (1,500+ native integrations, self-hosted, fair-code).

What I Evaluated First (That Didn't Work)

I started with Zapier because it's the obvious choice. Everyone uses it. Setup is fast. No infrastructure to manage.

Then I did the math on a 28-node workflow running 50 times per month. That's 1,400 tasks per month in Zapier's pricing model. Every single action step counts as a task.

Zapier's free tier caps at 100 tasks/month. I'd blow through that in 4 days. The paid tier starts at $19.99/month for 750 tasks, but I'd need the $69/month Team plan for the headroom needed.

Then I hit the real blocker: I needed custom validation logic to filter empty webhook payloads. Zapier's "Formatter" step couldn't handle it. I'd need 6-7 separate steps to approximate what one JavaScript function does natively.

Each of those steps burns another task. The cost compounds. The complexity explodes.

Cost Reality: The Numbers Nobody Shows You

n8n's software is free under fair-code license, but production requires a VPS (~$6/month). Even with infrastructure costs, it crushes Zapier's per-task pricing at scale.

Here's the honest breakdown:

Zapier:

Software: $0 (up to 100 tasks/month)
At 1,400 tasks/month: $69/month minimum = $828/year
At scale (5,000+ tasks): $69-$99/month = $828-$1,188/year
Infrastructure: $0 (cloud-hosted)

n8n:

Software: ₹0 forever (fair-code license, unlimited workflows and executions)
Infrastructure: DigitalOcean VPS at $6/month = $72/year
At any scale: Still $72/year (flat cost, no per-task pricing)

The critical insight: Zapier charges per task (every action step counts). A 28-node workflow burns 28 tasks per run. n8n charges per workflow execution - the entire 28-node run counts as one.

At 50 leads per month, Zapier's costs compound exponentially while n8n stays flat.

Note: You can run n8n locally via Cloudflare Tunnel for exactly ₹0 during development. But production lead automation handling real revenue needs a reliable VPS with guaranteed uptime.

Code Flexibility: The Real Dealbreaker

This was the actual dealbreaker. My production system needed what I call The 3-Layer Validation Pattern - a validation architecture that fixed a 40% blank email bug.

Here's the exact logic:

// n8n Code Node - validation.js
// Layer 1: Check if items exist and have data
if (!items || items.length === 0) return [];

// Layer 2: Validate the ID field exists and has correct format
const id = items[0].json?.id;
if (!id || typeof id !== 'string' || !id.startsWith('rec')) return [];

// Layer 3: Verify all required fields are present
const required = ['email', 'name', 'startTime'];
const hasAll = required.every(f => items[0].json[f]);
if (!hasAll) return [];

return items;

Try building this in Zapier's "Formatter" step. You literally can't. You'd need:

Filter step to check if data exists
Formatter step to extract the ID
Filter step to validate ID format
Formatter step to check email field
Formatter step to check name field
Formatter step to check startTime field
Filter step to combine all conditions

That's 7 separate Zapier steps (each burning a task) to do what one n8n Code node does natively. And the Zapier version is still less flexible because you can't use JavaScript's every() method or optional chaining (?.).

Is n8n Really Free?

The software is free under n8n's fair-code license - unlimited workflows, unlimited executions, zero licensing fees. But "free" doesn't mean "zero cost."

You pay for infrastructure. A production-ready setup needs:

VPS hosting ($4-20/month depending on load)
Domain name (optional, ~$10/year)
SSL certificate (free via Let's Encrypt)
Your time for setup and maintenance

The trade-off: You exchange convenience for control. Zapier is zero-setup but scales expensively. n8n requires 30 minutes of initial setup but costs stay flat forever.

At production scale, that trade pays off. Hard.

The Self-Hosting Production Setup

Here's the exact stack I used:

# Docker Compose on DigitalOcean VPS
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

# Public URL via Nginx reverse proxy
# Webhook-ready at https://yourdomain.com/webhook/...

Yes, you manage your own infrastructure. Yes, you handle updates. But in return:

Fixed, predictable costs. No surprises when leads spike.
Complete data privacy. Zero lead data passes through a third-party SaaS.
Raw webhook access. Cal.com, contact forms, and Airtable fire directly into your instance.

For Cal.com specifically, n8n's ability to inspect the raw webhook payload was critical. I caught an empty object ({}) bug that Zapier would have silently passed through - causing blank confirmation emails to real paying customers.

Where Each Tool Actually Wins

I'm being honest here. Both tools have legitimate use cases.

Zapier wins on:

Setup speed: First workflow running in 5 minutes vs 30 minutes for n8n
Non-technical users: True drag-and-drop, zero code knowledge required
App ecosystem: 9,000+ pre-built integrations vs n8n's 1,500+ native integrations
Zero infrastructure: Cloud-hosted, always on, nothing to maintain

n8n wins on:

Cost at scale: ₹0 software forever. Only pay for your VPS (~$6-20/month)
Code flexibility: Full JavaScript/Python. Any logic complexity, no sandbox restrictions
Data sovereignty: Everything stays on your server. Total privacy compliance
Debugging depth: Complete execution logs, step-by-step data inspection at every node
Fair-code transparency: Source code is available to audit, extend, or fork
AI-native nodes: 70+ dedicated AI/LLM nodes including LangChain integration

The trade-off is clear: Zapier wins on convenience (5-minute setup, zero maintenance) but loses on cost predictability (per-task pricing punishes scale). n8n requires infrastructure management (30-minute setup, monthly updates) but gives you complete data sovereignty and flat costs.

You trade convenience for control. At production scale, that trade pays off.

Can n8n Replace Zapier Completely?

n8n can replace Zapier for most automation workflows, but not all. The deciding factors are technical complexity and scale.

For personal quick automation (Slack → Notion, email filters), Zapier is faster to set up. For client projects with complex logic (lead management, multi-step validation, custom transformations), n8n wins every time.

One caveat: If you're building complex AI agents with multi-step reasoning, frameworks like LangChain or LangGraph are superior. They give you absolute control over agent state, tool calling, and reasoning loops. But they require heavy coding, and the "no-code speed" disappears entirely.

My take: For connecting services and orchestrating integrations, n8n is the best choice. For building intelligent agents that reason and decide, LangGraph wins. They're complementary, not competitors.

The Verdict

For the Aviators Training Centre project, n8n was the clear winner:

₹0 software cost vs Zapier's $828+/year (and growing with scale)
Complex validation logic that needs real JavaScript, not "Formatter" workarounds
3 interconnected workflows sharing data seamlessly
A client who needed a system that handles real revenue reliably, not a quick hack

My rule of thumb after building with both:

Personal quick automation (Slack → Notion, email filters) → Zapier. It's faster to set up.
Client projects with complex logic (lead management, multi-step validation) → n8n. Every time.
Scaling operations on a budget → n8n, always. The per-task pricing model will punish you.

Key Takeaways

The best automation tool isn't the most popular one - it's the one that fits your technical requirements AND your financial reality
At 50 leads/month with 28-node workflows, that's 1,400 tasks in Zapier vs 50 executions in n8n
One JavaScript Code node in n8n replaces 6-7 separate Zapier steps (and costs less)
Self-hosting adds 30 minutes of setup but eliminates punitive SaaS scaling costs forever
For production systems generating real revenue, engineering control matters more than drag-and-drop convenience

Live proof: The system runs at Aviators Training Centre handling real leads right now. Full source code is on GitHub. More automation deep dives on my portfolio.

I'm documenting my entire automation journey on Dev.to - follow for the next deep dives.

I've used both n8n and Zapier in production. For those running 100+ tasks/day, which pricing model actually works better for your use case? I'll share my cost calculator spreadsheet for every reply.$828/year (Team plan at $69/mo × 12)

Key Takeaways

n8n software is free but requires $6-20/month VPS infrastructure; Zapier charges $828+/year for equivalent workload
Zapier's per-task pricing compounds exponentially; n8n's per-execution model keeps costs flat at scale
Code flexibility is the real dealbreaker: n8n supports native JavaScript for complex validation logic that Zapier cannot handle
Self-hosting trades setup convenience (30 min vs 5 min) for long-term cost control and data sovereignty
Choose Zapier for quick personal automations; choose n8n for production systems with complex logic and scaling needs

FAQ

Is n8n completely free?

The software is free under n8n's fair-code license with unlimited workflows and executions. However, running it in production requires infrastructure costs (typically $6-20/month for a VPS). The total cost is still dramatically lower than Zapier's per-task pricing at scale.

Can n8n replace Zapier for all use cases?

No. Zapier wins for quick personal automations, non-technical users, and scenarios where you need one of its 9,000+ pre-built integrations immediately. n8n is better for complex logic, custom code requirements, cost-sensitive scaling, and data privacy needs.

How difficult is it to self-host n8n?

If you're comfortable with Docker and basic VPS management, setup takes about 30 minutes. You'll need to handle updates and monitor uptime yourself. The trade-off is complete control over your automation infrastructure and fixed monthly costs.

What's the real cost difference at scale?

For my 28-node workflow running 50+ times monthly (1,400+ Zapier tasks), n8n costs $6/month while Zapier requires the $69/month Team plan. At 100+ leads monthly, Zapier's costs scale even higher. n8n stays at $6/month regardless of execution volume.

Building 99.7% Reliable n8n Workflows: The Validation Guide

Aman Suryavanshi — Tue, 17 Feb 2026 13:37:59 +0000

How I Fixed the "Empty Object" Bug in n8n (and Hit 99.7% Reliability)

TL;DR:

Webhooks often send empty objects ({}) for cancellations, which JavaScript treats as "truthy."
Standard array length checks fail when n8n returns [{}].
A 3-layer validation system (Structure, ID, and Data) prevents blank emails from reaching customers.

Prerequisites

Basic knowledge of n8n workflows.
Understanding of JavaScript truthy/falsy values.
Experience handling webhooks from tools like Cal.com or Typeform.

The Problem: The Silent Killer of Automations

I recently faced a nightmare scenario while building a lead management system for the Aviators Training Centre. 40% of my booking confirmation emails were sending with blank data.

No name. No meeting time. Just empty fields.

Users received emails saying: "Hi , your meeting is scheduled for " with awkward blank spaces where their information should be. It looked unprofessional and risked losing potential students.

After deep-diving into the n8n execution logs, I found the culprit. Cal.com sends webhooks for both bookings and cancellations. When a cancellation happened, the payload was an empty object: {}.

Because n8n has alwaysOutputData: true enabled by default in many nodes, these empty objects passed through my filters. In JavaScript, an empty object is technically truthy, so my "if data exists" checks were waving them through to the email node.

What I Tried First (That Failed)

Before I found the solution, I went through several failed attempts that I'm sure many of you have tried too:

Attempt 1: Checking array length

if (bookingData.length > 0) return bookingData;

Why it failed: n8n often wraps the payload in an array. An array containing an empty object [{}] still has a length of 1.

Attempt 2: The simple truthy check

if (bookingData[0]) return bookingData;

Why it failed: As mentioned, {} is truthy. The check passes, but there is no usable data inside.

Attempt 3: Checking for a specific field

if (bookingData[0].id) return bookingData;

Why it failed: If the id field is missing entirely, this throws a null reference error and crashes the whole workflow execution.

The Solution: 3-Layer Validation Architecture

To solve this, I built a multi-layer validation system. This architecture ensures that only "healthy" data makes it to the final stages of the workflow.

Layer 1: Array Structure Check

First, we verify if we even have a list of data to look at. This catches completely empty responses or null values.

Layer 2: ID Field Validation

Next, we check if a unique identifier exists. Since I was using Airtable and Cal.com, I looked for an ID that followed a specific format (like starting with 'rec').

Layer 3: Meaningful Data Check

Finally, we ensure the object has more than just one or two keys. If an object only has an ID but no name or email, it's still useless for a confirmation email.

Implementing the Full Validation Function

Here is the exact code I used in a Code Node to filter out the noise. This function uses "semantic indicators" - if no valid data is found, it returns a specific flag (_noLeadsFound) that downstream nodes can easily recognize.

// src/utils/validation.js

function isValidLead(item) {
  // Layer 1: Check if the item and json property exist
  if (!item || !item.json) return false;

  const data = item.json;

  // Layer 2: Check ID exists and matches expected format
  if (!data.id || !data.id.startsWith('rec')) return false;

  // Layer 3: Check for required fields (Name, Email, Start Time)
  if (!data.name || !data.email || !data.startTime) return false;

  // Final Check: Ensure it's not just an object with an ID
  if (Object.keys(data).length <= 1) return false;

  return true;
}

const validLeads = items.filter(isValidLead);

if (validLeads.length === 0) {
  // Return a semantic indicator instead of an empty array
  return [{ json: { _noLeadsFound: true } }];
}

return validLeads;

The "Smart Indicator" Pattern

One of the biggest lessons I learned was using the _noLeadsFound flag. Instead of letting the workflow stop or error out, I pass this flag to an IF Node later in the flow:

// IF Node Condition
$input.first().json && 
!$input.first().json._noLeadsFound && 
$input.first().json.id

This prevents the "Empty Object" from ever reaching the email template, while still allowing the workflow to finish gracefully.

The Results: 99.7% Reliability

After deploying this 3-layer architecture at the Aviators Training Centre, the results were immediate.

Reliability: Jumped from 60% to 99.7%.
Blank Emails: Dropped to 0%.
Production Stats: Over 42 consecutive checks passed across three different triggers (Cal.com, Firebase, and Booking Management) with zero errors.

I no longer have to spend hours debugging execution logs to find out why a customer received a broken email. The system handles the edge cases automatically.

Key Takeaways

Never trust webhook data: Always assume the payload might be empty or malformed.
Objects are tricky: Remember that [{}] is truthy and has a length of 1.
Use Semantic Indicators: Passing a flag like _noLeadsFound is much cleaner than trying to handle nulls in every single node.
Validate in layers: Catch structure issues first, then ID issues, then data completeness.

Bookmark this pattern for the next time you build a customer-facing automation. It will save you from a lot of embarrassing "Hi [Blank]" emails.

What's your approach?

I used a custom Code Node for this validation, but I have seen people use complex chains of Filter nodes to achieve something similar. Which do you prefer: writing a bit of JavaScript or keeping it strictly no-code with more nodes?

I'm documenting my entire build-in-public journey here on Dev.to. If you want more practical n8n and Next.js patterns, hit the follow button.

Let's connect:

Next.js Lighthouse Optimization: 42 to 97 Case Study

Aman Suryavanshi — Sat, 24 Jan 2026 04:46:03 +0000

How I Boosted My Next.js Lighthouse Score from 42 to 97

We’ve all been there: you build a beautiful Next.js site, deploy it, and then run a Lighthouse audit only to see a sea of red circles.

That was me a few months ago. My project, the Aviators Training Centre website, launched with a Performance score of 42. Google ignored us, organic traffic was non-existent, and the Largest Contentful Paint (LCP) was a painful 5.8 seconds.

But after a systematic optimization, I pushed that score to 97. The result? We hit Page 1 on Google, generated over 50 organic leads, and drove ₹3 lakh+ in revenue.

TL;DR:

Images: Used next/image with priority loading to reduce size by 93%.
Code Splitting: Implemented dynamic imports to cut the main bundle by 67%.
Business Impact: Better Core Web Vitals = Page 1 rankings and real revenue.

Prerequisites

Before we dive in, you should have:

A basic understanding of Next.js and React.
A site deployed (or running locally) that you want to optimize.
Lighthouse (built into Chrome DevTools) to measure your progress.

The Problem: Why "Good Enough" Isn't Enough

When I first checked the metrics, they were grim:

First Contentful Paint (FCP): 3.2s (Target: <1.8s)
Largest Contentful Paint (LCP): 5.8s (Target: <2.5s)
Cumulative Layout Shift (CLS): 0.18 (Target: <0.1)

Google's algorithm prioritizes fast websites. If your site is slow, you aren't just annoying users—you're effectively invisible to search engines.

The 5-Step Optimization Strategy

1. Image Optimization (The Biggest Win)

Images are usually the heaviest part of any site. I switched every standard <img> tag to the Next.js <Image /> component. This automatically handles WebP conversion and resizing.

For "above-the-fold" images (like your Hero section), the priority prop is your best friend. It tells the browser to fetch that image immediately.

// src/components/HeroImage.js
import Image from 'next/image';

export default function HeroImage() {
  return (
    <Image
      src="/courses/cpl-training.png"
      alt="CPL Training"
      width={800}
      height={600}
      quality={85}
      priority={true} // Critical for LCP!
      placeholder="blur"
      sizes="(max-width: 768px) 100vw, 50vw"
    />
  );
}

2. Smart Code Splitting

Why load a heavy admin dashboard or a syntax highlighter on the homepage? You shouldn't. I used Next.js dynamic imports to ensure users only download the code they actually need.

// src/pages/index.js
import dynamic from 'next/dynamic';

// This component only loads when it's about to enter the viewport
const Testimonials = dynamic(
  () => import('@/components/Testimonials'),
  {
    loading: () => <div className="animate-pulse">Loading...</div>,
    ssr: false // Set to false if it doesn't need to be rendered on the server
  }
);

3. Font Optimization

Render-blocking fonts are a silent killer. Using next/font allows you to host fonts locally and use font-display: swap to prevent the "Flash of Invisible Text."

// src/layout.js
import { Inter } from 'next/font/google';

const inter = Inter({
  subsets: ['latin'],
  display: 'swap',
  variable: '--font-inter',
  preload: true,
});

4. Script Loading Strategy

Third-party scripts (Analytics, Chatbots) often hog the main thread. I used the next/script component to control exactly when these scripts load.

afterInteractive: For analytics (loads early but doesn't block).
lazyOnload: For non-critical scripts like chat widgets.

5. Aggressive Caching

For assets that rarely change (like your logo or UI icons), tell the browser to keep them for a long time. I updated my next.config.js to include immutable cache headers.

// next.config.js
module.exports = {
  async headers() {
    return [
      {
        source: '/:all*(svg|jpg|png|webp)',
        headers: [
          {
            key: 'Cache-Control',
            value: 'public, max-age=31536000, immutable',
          },
        ],
      },
    ];
  },
};

The Results: Numbers Don't Lie

After implementing these changes, the transformation was incredible:

Performance: 42 → 97
LCP: 5.8s → 1.4s (4x faster)
TBT (Total Blocking Time): 890ms → 120ms (7x reduction)

This technical cleanup led to Page 1 rankings for 20+ keywords and 19,300 impressions in just 6 months.

Key Takeaways for Your Next Project

Lighthouse is a business tool: A high score isn't just for ego; it's for SEO and conversions.
Optimize early: Don't wait until after launch. We lost two months of potential traffic because we deployed a slow site first.
Use the built-ins: Next.js provides Image, Font, and Script components for a reason. Use them!

What’s your biggest struggle when it comes to web performance? Is it third-party scripts, heavy images, or something else? Let’s chat in the comments! I’d love to hear how you handle these bottlenecks.

If you found this helpful, feel free to connect with me—I'm always happy to talk Next.js and automation!

How I Built an Organic Lead Gen Machine: A ₹3 Lakh Case Study

Aman Suryavanshi — Fri, 16 Jan 2026 15:47:24 +0000

How I Replaced ₹50k/Month Ad Spend with a Next.js + n8n Lead Machine

TL;DR:

I built a full-stack lead generation system for a flight school that cut ad spend to zero while generating ₹3,00,000+ in revenue.
The stack uses Next.js 14, n8n, Firebase, and Airtable—all running on ₹0/month infrastructure costs.
Key technical win: A non-blocking webhook architecture that ensures 99.7% reliability even if the automation backend is busy.

Prerequisites

To follow along with this architecture, you should have a basic understanding of:

Next.js (App Router & API Routes)
Webhooks (How to send and receive JSON data)
Low-code automation (Basic familiarity with n8n or Zapier)

The Problem: 100% Ad Dependency

I recently worked with Aviators Training Centre, a premier DGCA ground school in India. When we started, they were caught in a classic "ad-spend trap":

Bleeding Cash: Spending ₹35,000–₹50,000/month on Facebook ads.
High CPL: Paying nearly ₹800 per lead.
Manual Chaos: Leads were scattered across WhatsApp, and the owner spent 4 hours a day on admin work instead of teaching.

The client asked me: "Can we stop depending on paid ads?"

I said yes. But to do that, we didn't just need a website; we needed a revenue machine.

The Architecture: The "Zero-Cost" Stack

I chose tools that offer generous free tiers or can be self-hosted to keep the overhead at exactly ₹0/month:

Frontend: Next.js 14 (Vercel) for SSR and SEO.
Database: Firebase Realtime DB (Free Tier) for instant lead storage.
Automation: n8n (Self-hosted) to glue everything together.
CRM: Airtable for a visual sales pipeline.
CMS: Sanity.io for SEO-optimized blog content.

1. The Non-Blocking Webhook Pattern

One of the biggest mistakes I see beginners make is making the user wait for an automation to finish. If your n8n server is slow, your user sees a spinning wheel—or worse, a timeout error.

I built a non-blocking architecture. The Next.js API route saves the data to Firebase immediately and triggers the webhook in the background. The user gets a "Success" message in milliseconds.

// src/app/api/lead/route.ts
import { db } from '@/lib/firebase';
import { ref, push } from 'firebase/database';

export async function POST(req: Request) {
  const data = await req.json();

  try {
    // 1. Save to Firebase immediately (The Source of Truth)
    await push(ref(db, 'leads'), {
      ...data,
      timestamp: Date.now(),
    });

    // 2. Trigger n8n Webhook (Background task)
    // We don't 'await' this if we want maximum speed,
    // or we use a try/catch to ensure user UX isn't broken.
    fetch(process.env.N8N_WEBHOOK_URL!, {
      method: 'POST',
      body: JSON.stringify(data),
    }).catch(err => console.error("n8n Trigger Failed:", err));

    return new Response(JSON.stringify({ success: true }), { status: 200 });
  } catch (error) {
    return new Response(JSON.stringify({ error: 'Database failure' }), { status: 500 });
  }
}

2. Solving the Lead Attribution Mystery

If you're moving away from ads, you need to know where your organic leads are coming from. I built a simple UTM tracking utility that captures URL parameters and stores them in the browser session.

// src/utils/trackUtm.js
export const getUtmParams = () => {
  if (typeof window === 'undefined') return {};

  const params = new URLSearchParams(window.location.search);
  return {
    source: params.get('utm_source') || 'organic',
    medium: params.get('utm_medium') || 'direct',
    campaign: params.get('utm_campaign') || 'none',
    content: params.get('utm_content') || 'none',
  };
};

When a user submits a form, we bundle these UTMs with their contact info. This allowed the client to see that 15% of their high-quality leads were actually coming from AI search engines like Perplexity and ChatGPT!

Key Challenges & "Aha!" Moments

The n8n "Empty Object" Bug

Early on, 40% of our booking confirmations were sending blank emails. I realized that if the webhook payload was slightly malformed, n8n would still execute but with empty data.

The Fix: I implemented a 3-layer validation system inside n8n using an "If Node" to check for the existence of the email and name fields before proceeding. Reliability shot up from 60% to 99.7%.

Lighthouse Optimization

SEO was our primary growth driver. By using Next.js next/image and aggressive code splitting, I took the Lighthouse score from under 50 to 95+. This single change pushed 20+ keywords to Page 1 of Google India within 4 months.

The Results (The Numbers Don't Lie)

Revenue: ₹3,00,000+ from organic leads.
Ad Spend: Reduced from ₹50,000/month to ₹0.
Admin Time: 4 hours/day → 30 mins/day (85% reduction).
Response Time: Leads get a personalized email/WhatsApp in <2 minutes instead of 6 hours.

Key Takeaways for Developers

UX is King: Never make your user wait for a third-party API (like n8n or Airtable). Save to your DB first, then trigger automations.
Free Tier Stacking is a Superpower: You don't need a huge budget to build professional-grade systems. Vercel + Firebase + Airtable is a lethal combo for small business clients.
Performance = Revenue: In this project, a 95+ Lighthouse score directly correlated to ₹3L in revenue. Speed isn't just a dev metric; it's a business metric.

What do you think?

I'm curious—how do you handle lead processing in your apps? Do you prefer a heavy backend like Node/Express, or are you leaning into the "Serverless + Automation" approach like I did here?

Let's discuss in the comments! 👇