Ekosystem
Język

Blog

n8n vs Zapier vs Make.com 2026: Który wybrać i kiedy przestać używać obu

  • n8n
  • zapier
  • make
  • automation
Spis treści

Każdy klient pyta mnie to samo. "Mamy Zapiera, płacimy $X miesięcznie, czy n8n jest lepsze?" Albo: "Słyszałem o Make.com, trzeba przechodzić?"

Przez ostatnie lata zbudowałem workflows na wszystkich tych platformach — od prostych lead enrichment pipelines po złożone multi-step automations z GPT-4, bazami danych i custom webhookami. Wiem dokładnie kiedy każda z nich ma sens, i kiedy wyrzucić wszystkie i napisać własne 50 linii Node.js.

Ten artykuł to mój szczery breakdown. Bez affiliate linków, bez sponsorów. Tylko to, co faktycznie działa.

Spis treści


1. TL;DR — decyzja w 30 sekund

Zanim wejdziemy głębiej, tu jest mój skrócony verdict:

ScenariuszMój wybór
Startup, <500 zadań/miesiąc, nie-techniczna ekipaZapier
Firma, >500 zadań/miesiąc, masz deweloperan8n self-hosted
Złożone multi-step flows z wizualnym designeremMake.com
Open-source, chcesz własny hosting + custom nodesn8n
Prosty webhook handler, 1-2 integracjeNapisz własne
Enterprise, compliance, on-premisen8n Enterprise

Teraz wejdźmy w szczegóły.


2. Koszty: Gdzie leżą realne pieniądze

Pierwszy szok dla każdego klienta: Zapier jest drogi. Naprawdę drogi, kiedy Twoje automation zaczyna rosnąć.

Porównanie cen (maj 2026)

kod
ZAPIER
─────────────────────────────────────────
Free:     100 zadań/miesiąc, 5 Zaps
Starter:  $29.99/mies → 750 zadań
Professional: $73.50/mies → 2,000 zadań
Team:     $448.50/mies → 50,000 zadań
Enterprise: custom pricing

MAKE.COM (dawny Integromat)
─────────────────────────────────────────
Free:     1,000 operacji/miesiąc
Core:     $9/mies → 10,000 operacji
Pro:      $16/mies → 10,000 + priorytet
Teams:    $29/mies → 10,000
Enterprise: custom

N8N
─────────────────────────────────────────
Self-hosted: $0 (zawsze)
n8n Cloud Starter: $24/mies → 2,500 wykonań
n8n Cloud Pro: $60/mies → 10,000 wykonań
Enterprise self-hosted: ~$500/mies (big teams)

Reality check dla mojego typowego klienta:

kod
Firma z 15,000 zadań/miesiąc:

Zapier Team:       $448.50/mies = $5,382/rok
Make.com Teams:    ~$50/mies    = $600/rok (x operacje)
n8n self-hosted:   VPS €5/mies  = €60/rok + mój czas na setup

→ Zapier vs n8n self-hosted: różnica ~$5,300/rok
→ Za te pieniądze możesz zapłacić developerowi
  za 2-3 dni roboczych custom n8n setup
  i mieć to raz na zawsze

Zapier ma swoje miejsce — ale nie tam, gdzie myślisz.


3. n8n — dlaczego to mój default

n8n to mój default od 2023 roku i nic tego nie zmieniło. Oto dlaczego.

Co n8n robi inaczej

Fair-code license + self-hosted = pełna kontrola. Twoje dane nie opuszczają Twojego serwera. Dla klientów z compliance (GDPR, healthcare, fintech) — to nie jest opcja, to wymóg.

Node-based visual editor z możliwością pisania JavaScript/Python bezpośrednio w node'ach. To jest kluczowe — nie jesteś ograniczony do tego co platforma oferuje "out of the box".

kod
Typowy n8n workflow:
Webhook → HTTP Request → Code Node (JS) → PostgreSQL → Send Email

vs Zapier:
Webhook Trigger → Zapier Action → Zapier Action → Email

Różnica: W n8n możesz napisać dowolny kod w środku.
W Zapierze jesteś ograniczony do oficjalnych integracji.

Custom nodes — to co naprawdę zmienia grę

Kiedy żaden wbudowany node nie wystarczy, piszesz własny:

typescript
// custom-node/nodes/MyApiNode/MyApiNode.node.ts
import {
  IExecuteFunctions,
  INodeExecutionData,
  INodeType,
  INodeTypeDescription,
} from 'n8n-workflow';

export class MyApiNode implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'My Company API',
    name: 'myApiNode',
    icon: 'file:myapi.svg',
    group: ['transform'],
    version: 1,
    description: 'Interact with My Company API',
    defaults: {
      name: 'My API',
    },
    inputs: ['main'],
    outputs: ['main'],
    credentials: [
      {
        name: 'myApiCredentials',
        required: true,
      },
    ],
    properties: [
      {
        displayName: 'Operation',
        name: 'operation',
        type: 'options',
        options: [
          { name: 'Create Lead', value: 'createLead' },
          { name: 'Update Contact', value: 'updateContact' },
          { name: 'Get Analytics', value: 'getAnalytics' },
        ],
        default: 'createLead',
      },
      {
        displayName: 'Email',
        name: 'email',
        type: 'string',
        default: '',
        displayOptions: {
          show: { operation: ['createLead'] },
        },
      },
    ],
  };

  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
    const items = this.getInputData();
    const operation = this.getNodeParameter('operation', 0) as string;
    const credentials = await this.getCredentials('myApiCredentials');

    const results: INodeExecutionData[] = [];

    for (let i = 0; i < items.length; i++) {
      if (operation === 'createLead') {
        const email = this.getNodeParameter('email', i) as string;

        const response = await this.helpers.request({
          method: 'POST',
          url: `${credentials.baseUrl}/leads`,
          headers: {
            Authorization: `Bearer ${credentials.apiKey}`,
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ email, source: 'n8n' }),
        });

        results.push({ json: JSON.parse(response) });
      }
    }

    return [results];
  }
}

Żaden Zapier ani Make.com nie daje Ci takiej elastyczności. To jest biblioteka npm — możesz zrobić dosłownie wszystko.

Code Node — szybka transformacja danych

Bez custom node, bezpośrednio w workflow:

javascript
// n8n Code Node — JavaScript
// Transformacja danych z CRM do formatu email marketingu

const leads = $input.all();

const transformed = leads
  .filter(item => item.json.status === 'qualified')
  .map(item => ({
    email: item.json.email,
    firstName: item.json.name.split(' ')[0],
    company: item.json.company || 'Unknown',
    score: item.json.leadScore,
    // Bucket scoring dla segmentacji
    segment: item.json.leadScore >= 80 ? 'hot' 
            : item.json.leadScore >= 50 ? 'warm' 
            : 'cold',
    // Personalizacja wiadomości
    subject: item.json.leadScore >= 80 
      ? `${item.json.name.split(' ')[0]}, mamy dla Ciebie coś specjalnego`
      : 'Sprawdź nasze rozwiązania',
  }));

return transformed.map(item => ({ json: item }));

To jest rzecz, którą w Zapierze musisz opakować w zewnętrzny kod serwer lub zapłacić za Zapier Code, który i tak ma limity.

Kiedy n8n jest oczywistym wyborem

  • Masz > 2,000 zadań/miesiąc i chcesz kontrolować koszty

  • Twoje dane muszą zostać on-premise (GDPR, healthcare, banking)

  • Potrzebujesz custom logiki w środku workflow

  • Chcesz integrować wewnętrzne API których Zapier nie obsługuje

  • Masz dewelopera który ustawi to raz


4. Zapier — kiedy ma sens, kiedy nie

Zapier ma jeden argument, którego n8n nie pobije: ekosystem i prostota dla nie-technicznych użytkowników.

6,000+ integracji. Interfejs gdzie marketingowiec bez wiedzy technicznej kliknie w 10 minut i ma działający workflow. To ma realną wartość.

Kiedy Zapier wygrywał — use case

kod
Scenariusz: Marketing team, startup, 5 osób
Problem: Nowy lead w Typeform → HubSpot CRM → 
         Slack notification → Add to Google Sheets

Kto to robi: Growth hacker, non-technical

Z Zapierem:
→ 20 minut konfiguracji
→ Działa
→ 0 kosztów utrzymania
→ Bez IT involvement

Z n8n self-hosted:
→ Trzeba kogoś do setupu serwera
→ Trzeba kogoś kto zna n8n UI
→ Maintenance responsibility
→ Ale: od 500 leadów/mies już taniej

Verdict: Jeśli ekipa to nie-techniczni i flows są proste → Zapier. Jak tylko przekraczasz 1,000 zadań/mies lub potrzebujesz czegoś custom → n8n.

Pułapki Zapiera, których nikt nie mówi

Zadania liczą się inaczej niż myślisz. W Zapierze każdy krok w Zap to osobne zadanie. Flow z 5 krokami = 5 zadań. Masz Zap który odpala się 200 razy/dzień → 200 × 5 = 1,000 zadań/dzień. W miesiącu: 30,000. Professional plan: $73.50/mies. OK, ale przy 50 triggerach/dzień z 5-krokowymi Zapsami: Team plan, $448/mies.

kod
Kalkulacja realna — flow 8 kroków, 100 triggerów/dzień:

Zadania/dzień:  100 × 8 = 800
Zadania/miesiąc: 800 × 30 = 24,000

Zapier Professional (2,000 zadań): ❌ za mało
Zapier Team (50,000 zadań): $448.50/mies ✓

n8n self-hosted na VPS Hetzner (CAX11, €4.15/mies):
→ Unlimited wykonań
→ Unlimited kroki
→ €50/rok na hosting

Różnica: ~$5,338/rok

Vendor lock-in jest realny. Przeprowadzałem migrację klienta z Zapiera na n8n — 47 Zapsów, 3 tygodnie roboty. Dlatego: zanim zaczniesz w Zapierze, pomyśl o skalowalności.


5. Make.com — wizualny king, ale...

Make.com (dawniej Integromat) ma najlepszy wizualny builder ze wszystkich trzech. Canvas z flow charts, szczegółowa kontrola nad każdym połączeniem, wbudowane error handling, iteratory, agregatory — to jest power-user tool.

Co Make.com robi lepiej

Routing i conditional logic jest w Make.com bardziej intuicyjny:

kod
Make.com Router:
→ Branch A: status = 'new' → Send welcome email
→ Branch B: status = 'returning' → Send personalized offer  
→ Branch C: status = 'vip' → Notify account manager + Send gift

vs n8n:
→ IF Node → Switch Node → ... 
→ Można, ale bardziej verbose

Iteratory i agregatory — Make.com obsługuje to wizualnie w sposób który n8n dopiero dogania.

Cena vs Make.com — przy standardowym użyciu Make.com jest najtańszy z trójki. 10,000 operacji za $9/mies to poważna propozycja.

Ale tu jest catch

Make.com jest cloud-only. Brak self-hosted opcji. Twoje dane przechodzą przez ich serwery. Dla wielu projektów to blocker.

Też: "operacja" ≠ "zadanie" w Zapierze. W Make.com jedna operacja to jeden "routed bundle" — w złożonych flows możesz zużywać operacje szybciej niż myślisz.

kod
Make.com przykład — gdzie operacje lecą szybko:

Webhook trigger (1 bundle = 1 operacja)
→ HTTP Request: lista kontaktów [100 items]
→ Iterator: rozwija 100 items
→ Każdy item przez HTTP Request = 100 operacji
→ Każdy item przez Email module = 100 operacji

Łącznie: 1 + 1 + 100 + 100 = 202 operacje
Za 1 trigger event.

Przy 50 takich triggerach/dzień:
202 × 50 × 30 = 303,000 operacji/mies
Core plan (10,000): za mało
Trzeba wyższy tier

Kiedy wybieram Make.com

  • Klient non-technical, potrzebuje sam utrzymywać workflow

  • Złożona conditional logic, wiele branches

  • Integracje z niszowymi SaaSami których n8n nie ma natywnie

  • Prototypowanie szybkich automations przed custom implementacją


6. ActivePieces & Pipedream — dark horses 2026

Dwa projekty, które obserwuję i polecam sprawdzić.

ActivePieces

Open-source, self-hosted, UI bardzo podobny do n8n ale prostszy. Projekt od 2022, aktywnie rozwijany, community rośnie.

kod
Co ActivePieces robi dobrze:
→ Prostszy onboarding niż n8n
→ Docker setup w 5 minut
→ 100% open-source (MIT license)
→ Rosnąca lista natywnych integracji
→ TypeScript pieces (łatwiejsze niż n8n nodes)

Gdzie nie dogania n8n:
→ Mniej zaawansowane error handling
→ Mniejszy ekosystem nodes
→ Słabszy Code node
→ Młodszy projekt = mniej battle-tested

Kiedy użyć: Prosty self-hosted automation bez deep customization. Dobra alternatywa dla Zapiera dla non-technical teams którzy chcą self-hosted.

Pipedream

Zupełnie inna filozofia — code-first, developer-focused. Każdy workflow to de facto Node.js/Python script z wbudowanymi triggerami.

javascript
// Pipedream step — to jest po prostu Node.js
export default defineComponent({
  props: {
    github: {
      type: "app",
      app: "github",
    },
  },
  async run({ steps, $ }) {
    const issues = await this.github.getIssues({
      owner: "my-org",
      repo: "my-repo",
      state: "open",
    });
    
    // Pełny Node.js - możesz zaimportować dowolny npm package
    const { Resend } = require("resend");
    const resend = new Resend(process.env.RESEND_API_KEY);
    
    for (const issue of issues) {
      if (issue.labels.includes('critical')) {
        await resend.emails.send({
          from: "alerts@mycompany.com",
          to: "team@mycompany.com",
          subject: `CRITICAL: ${issue.title}`,
          html: `<p>${issue.body}</p>`,
        });
      }
    }
    
    return { processed: issues.length };
  },
});

Kiedy użyć Pipedream: Developer który chce szybki automation bez stawiania własnego serwera. Free tier (10,000 kredytów/mies) jest szczodry.


7. AI Workflows — n8n + GPT-4 w praktyce

To jest to, co klientów interesuje najbardziej w 2026. n8n + AI = potężna kombinacja.

Lead Enrichment Pipeline — pełny przykład

Real workflow który zbudowałem dla klienta SaaS:

kod
TRIGGER: Nowy lead w bazie danych (webhook z Next.js app)
    ↓
KROK 1: HTTP Request → Clearbit API
        Enrich lead danymi firmowymi
    ↓  
KROK 2: Code Node (JS) — przygotuj prompt
        Zbierz wszystkie dane o leadzie
    ↓
KROK 3: OpenAI Node — GPT-4 Turbo
        Oceń lead + wygeneruj spersonalizowany email
    ↓
KROK 4: IF Node — lead score >= 70?
        TAK → Krok 5A (hot lead flow)
        NIE → Krok 5B (nurture flow)
    ↓
KROK 5A: 
  - Slack notification → #sales channel
  - HubSpot: Assign to senior rep
  - Resend: Send personalized email (GPT-4 generated)
    
KROK 5B:
  - HubSpot: Add to nurture sequence
  - Resend: Send educational content

Code Node który generuje prompt dla GPT-4:

javascript
// n8n Code Node — przygotuj lead scoring prompt
const lead = $input.first().json;
const clearbitData = $('HTTP Request Clearbit').first().json;

const prompt = `
Jesteś ekspertem w kwalifikacji leadów B2B SaaS.

DANE LEADA:
- Email: ${lead.email}
- Rola: ${lead.jobTitle || 'nieznana'}
- Firma: ${clearbitData.company?.name || lead.company}
- Branża: ${clearbitData.company?.category?.industry || 'nieznana'}
- Liczba pracowników: ${clearbitData.company?.metrics?.employees || 'nieznana'}
- Kraj: ${clearbitData.company?.geo?.country || 'nieznany'}
- MRR firmy (estym.): ${clearbitData.company?.metrics?.estimatedAnnualRevenue || 'nieznane'}
- Jak dowiedział się o nas: ${lead.source || 'organic'}
- Strona referencyjna: ${lead.referrer || 'direct'}

ZADANIE:
1. Oceń lead w skali 0-100 (lead score)
2. Uzasadnij ocenę w 2-3 zdaniach
3. Wygeneruj spersonalizowaną pierwszą linię cold email (max 20 słów)
4. Wskaż główny pain point tej firmy na podstawie branży i rozmiaru

Odpowiedz w JSON:
{
  "score": number,
  "reasoning": "string",
  "emailOpener": "string", 
  "painPoint": "string"
}
`;

return [{ json: { prompt, leadData: lead, enrichedData: clearbitData } }];

OpenAI Node configuration w n8n:

json
{
  "model": "gpt-4-turbo",
  "messages": [
    {
      "role": "user",
      "content": "={{ $json.prompt }}"
    }
  ],
  "response_format": { "type": "json_object" },
  "temperature": 0.3,
  "max_tokens": 500
}

Koszt tego workflow vs Zapier

kod
n8n self-hosted (Hetzner CAX11):
→ Server: €4.15/mies
→ OpenAI API: ~$0.001/lead (GPT-4 Turbo, ~800 tokens)
→ Clearbit: zależy od planu (~$0.01-0.05/lookup)
→ Resend: $0.001/email (free tier do 3,000 emaili)

Przy 1,000 leadów/mies:
→ n8n: €4.15 + ~$15 AI + ~$30 Clearbit = ~$52/mies

Z Zapierem (ten sam flow, 6 kroków):
→ 1,000 × 6 = 6,000 zadań/mies
→ Zapier Professional ($73.50) — mieści się
→ PLUS: Zapier nie ma natywnie "Code Node" z pełnym Node.js
  → potrzebujesz external function albo Zapier Premium Code
→ Realny koszt: $73.50 + OpenAI + Clearbit + więcej złożoności

Różnica na korzyść n8n: ~$20-25/mies tylko na platformie.
Przy 10,000 leadów: różnica robi się znacząca.

8. Self-hosted n8n na produkcji — pełny setup

Jeśli decydujesz się na n8n self-hosted, tu jest jak to zrobić porządnie.

Docker Compose (minimalna produkcja)

yaml
# docker-compose.yml
version: '3.8'

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n:latest
    restart: always
    ports:
      - "127.0.0.1:5678:5678"
    environment:
      - N8N_HOST=${N8N_HOST}
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - NODE_ENV=production
      - WEBHOOK_URL=https://${N8N_HOST}/
      - GENERIC_TIMEZONE=Europe/Warsaw
      # Database — PostgreSQL zamiast SQLite na produkcji!
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      # Queue mode dla niezawodności
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_BULL_REDIS_PORT=6379
      # Security
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
      # Limity
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=168
    volumes:
      - n8n_data:/home/node/.n8n
      - ./custom-nodes:/home/node/.n8n/custom
    depends_on:
      - postgres
      - redis

  n8n-worker:
    image: docker.n8n.io/n8nio/n8n:latest
    restart: always
    command: worker
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - EXECUTIONS_MODE=queue
      - QUEUE_BULL_REDIS_HOST=redis
      - QUEUE_BULL_REDIS_PORT=6379
      - N8N_ENCRYPTION_KEY=${N8N_ENCRYPTION_KEY}
    depends_on:
      - postgres
      - redis
      - n8n

  postgres:
    image: postgres:15-alpine
    restart: always
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    restart: always
    volumes:
      - redis_data:/data

volumes:
  n8n_data:
  postgres_data:
  redis_data:

Nginx reverse proxy z SSL (Certbot):

nginx
# /etc/nginx/sites-available/n8n
server {
    listen 443 ssl http2;
    server_name n8n.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/n8n.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.yourdomain.com/privkey.pem;

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header X-Content-Type-Options "nosniff" always;

    location / {
        proxy_pass http://127.0.0.1:5678;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        # WebSocket support (ważne dla n8n UI)
        proxy_read_timeout 86400;
    }
}

server {
    listen 80;
    server_name n8n.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

Backup strategy (critical!)

bash
#!/bin/bash
# /opt/n8n-backup.sh — uruchamiaj codziennie przez cron

BACKUP_DIR="/opt/backups/n8n"
DATE=$(date +%Y%m%d_%H%M%S)
S3_BUCKET="your-backup-bucket"

mkdir -p $BACKUP_DIR

# Backup PostgreSQL
docker exec n8n-postgres-1 pg_dump -U n8n n8n | \
  gzip > $BACKUP_DIR/n8n_db_$DATE.sql.gz

# Backup n8n data volume (credentials, workflows config)
docker run --rm \
  -v n8n_data:/data \
  -v $BACKUP_DIR:/backup \
  alpine tar czf /backup/n8n_data_$DATE.tar.gz /data

# Upload to S3
aws s3 cp $BACKUP_DIR/n8n_db_$DATE.sql.gz s3://$S3_BUCKET/
aws s3 cp $BACKUP_DIR/n8n_data_$DATE.tar.gz s3://$S3_BUCKET/

# Cleanup lokalnych backupów starszych niż 7 dni
find $BACKUP_DIR -mtime +7 -delete

echo "Backup completed: $DATE"
bash
# Crontab — codziennie o 2:00 w nocy
0 2 * * * /opt/n8n-backup.sh >> /var/log/n8n-backup.log 2>&1

Monitoring

typescript
// webhook endpoint do monitorowania n8n health
// Możesz to wpiąć w UptimeRobot / Better Uptime

// GET https://n8n.yourdomain.com/healthz
// Expected response: {"status":"ok"}

// Dodatkowo: workflow który wysyła alert jeśli n8n nie działa
// Ustaw external cron (cron-job.org, free) który co 5 min
// wysyła request do Twojego n8n webhook.
// Jeśli brak odpowiedzi przez 15 min → alert na Slack/email

9. Kiedy olać wszystko i napisać własne

Szczera odpowiedź: częściej niż myślisz.

Jeśli Twój workflow to:

  • Jeden webhook trigger

  • 2-3 proste transformacje danych

  • Jeden output (API call / database insert / email)

...to 40 linii TypeScript jest lepszym rozwiązaniem niż konfigurowanie n8n/Zapier/Make.

typescript
// Prosty lead pipeline — Next.js API Route
// Zamiast n8n workflow z 5 nodami

import { NextRequest, NextResponse } from 'next/server';
import { Resend } from 'resend';
import { db } from '@/lib/db';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function POST(req: NextRequest) {
  const body = await req.json();
  
  // Walidacja
  if (!body.email || !body.name) {
    return NextResponse.json({ error: 'Missing fields' }, { status: 400 });
  }

  // Save to DB
  const lead = await db.lead.create({
    data: {
      email: body.email,
      name: body.name,
      source: body.source || 'website',
      createdAt: new Date(),
    },
  });

  // Notify sales team
  await fetch(process.env.SLACK_WEBHOOK_URL!, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      text: `🔥 New lead: *${body.name}* (${body.email})`,
    }),
  });

  // Send welcome email
  await resend.emails.send({
    from: 'hello@yourcompany.com',
    to: body.email,
    subject: `Cześć ${body.name.split(' ')[0]}!`,
    react: WelcomeEmail({ name: body.name }),
  });

  return NextResponse.json({ success: true, id: lead.id });
}

Kiedy custom code wygrywa:

  • Masz full-stack app i tak — dokładasz endpoint

  • Flow jest prosty i stabilny (nie zmienia się co tydzień)

  • Performance jest kluczowy (brak overhead no-code layer)

  • Chcesz full type safety, full control, zero vendor dependency

Kiedy n8n/Zapier/Make wygrywa:

  • Non-technical user musi sam utrzymywać workflow

  • Szybkie iteracje, flow zmienia się często

  • Dużo różnych systemów do połączenia (Salesforce + HubSpot + Stripe + Slack...)

  • Potrzebujesz visual debugging i error logs bez czytania kodu


10. Mój decision framework

Po wszystkich tych projektach, to jak podchodzę do każdej nowej sytuacji:

kod
START
  │
  ▼
Czy workflow zmienia się często lub zarządza nim non-techniczna osoba?
  │
  ├── NIE ──► Napisz własny kod. Koniec.
  │
  └── TAK
        │
        ▼
      Czy dane muszą zostać on-premise (GDPR, compliance)?
        │
        ├── TAK ──► n8n self-hosted. Koniec.
        │
        └── NIE
              │
              ▼
            Ile zadań/operacji miesięcznie?
              │
              ├── < 1,000 ──► Zapier (prostota) lub Make.com (cena)
              │
              ├── 1,000–10,000 ──► Make.com (najtańszy cloud)
              │                   lub n8n Cloud Starter
              │
              └── > 10,000 ──► n8n self-hosted (zawsze)

Moje aktualne setup dla projektów klientów

Typ klientaRozwiązaniePowód
Startup, non-technical teamZapier StarterProstota, szybki start
SaaS, 10K+ events/miesn8n self-hostedKoszty, control
E-commerce z compliancen8n EnterpriseGDPR, on-premise
Agencja marketingowaMake.com ProVisual, niedrogi, team features
Developer który chce autoCustom codeKontrola, zero overhead
Duża firma, wewnętrzne flowsn8n + custom nodesIntegracje wewnętrznych API

Podsumowanie

n8n to mój default dla każdego projektu który przekracza próg "proste 5-minutowe kliknięcia". Self-hosted, unlimited, pełna kontrola, JS w środku.

Zapier ma sens dla non-technical teams i małej skali. Jak tylko skala rośnie — koszty rosną nieliniowo.

Make.com to najlepsza opcja jeśli chcesz cloud + visual + rozsądną cenę + złożone conditional flows.

Custom code wygrywa kiedy flow jest prosty, stabilny, i masz developera. Zero vendor dependency.

Jeśli chcesz żebym ocenił Twój konkretny setup albo pomógł podjąć decyzję — napisz do mnie. Chętnie przejrzę co masz i powiem wprost co byś powinien zmienić.


Ostatnia aktualizacja: maj 2026. Ceny i limity platform mogą się zmieniać — sprawdź aktualne cenniki na stronach vendorów.

n8n vs Zapier vs Make.com 2026: Który wybrać i kiedy przestać używać obu | NextGenCode