Automação com n8n: Criando Workflows Inteligentes

Descobri o n8n há alguns meses e desde então automatizei praticamente todo meu fluxo de trabalho. Aqui compartilho os workflows mais úteis que criei.

Por que n8n?

Depois de testar Zapier, Make (antigo Integromat) e outras ferramentas, o n8n ganhou por ser:

• Open Source e self-hosted
• Flexível com JavaScript personalizado
• Visual e fácil de debugar
• Sem limites de execuções

Workflows que Transformaram Minha Produtividade

1. Monitoramento de Projetos GitHub

Problema: Perder atualizações importantes nos repositórios

Solução:

// Webhook do GitHub → Filtro → Slack

// Node de filtro personalizado
const importantEvents = [
  "issues.opened",
  "pull_request.opened",
  "push.master",
  "release.published",
];

if (importantEvents.includes($input.headers["x-github-event"])) {
  return $input.all();
}

return [];

Resultado: Zero notificações perdidas, foco apenas no que importa.

2. Lead Scoring Automático

Problema: Qualificar leads manualmente tomava muito tempo

Solução:

// Webhook → Score Calculation → CRM Update

const lead = $node["Webhook"].json;
let score = 0;

// Scoring baseado em dados
if (lead.company_size > 100) score += 30;
if (lead.role.includes("CTO") || lead.role.includes("Tech Lead")) score += 25;
if (lead.budget > 50000) score += 20;
if (lead.urgency === "immediate") score += 15;
if (lead.tech_stack.includes("React") || lead.tech_stack.includes("Next.js"))
  score += 10;

// Classificação
let category = "Cold";
if (score >= 60) category = "Hot";
else if (score >= 40) category = "Warm";

return {
  lead_id: lead.id,
  score: score,
  category: category,
  next_action: score >= 60 ? "immediate_contact" : "nurture_sequence",
};

Resultado: 70% menos tempo qualificando leads, conversão +40%.

3. Content Pipeline Automático

Problema: Distribuir conteúdo em múltiplas plataformas manualmente

Solução:

// RSS Feed → Content Processing → Multi-platform Publishing

// Processamento de conteúdo
const article = $node["RSS"].json;

// Adaptar para cada plataforma
const platforms = {
  linkedin: {
    text: article.title + "\n\n" + article.excerpt + "\n\n" + article.link,
    max_length: 1300,
  },
  twitter: {
    text: article.title + " " + article.link,
    max_length: 280,
  },
  telegram: {
    text: `📝 *${article.title}*\n\n${article.excerpt}\n\n[Ler mais](${article.link})`,
    parse_mode: "Markdown",
  },
};

return Object.entries(platforms).map(([platform, config]) => ({
  platform,
  content: config.text.substring(0, config.max_length),
  ...config,
}));

Resultado: Conteúdo distribuído automaticamente, +300% alcance.

4. Customer Success Automation

Problema: Acompanhar jornada do cliente manualmente

Solução:

// Database Trigger → Journey Analysis → Action

const customer = $node["Database"].json;
const daysSinceSignup = Math.floor(
  (Date.now() - new Date(customer.signup_date)) / (1000 * 60 * 60 * 24)
);

const journeyStages = [
  {
    day: 1,
    action: "welcome_email",
    condition: () => true,
  },
  {
    day: 3,
    action: "onboarding_check",
    condition: () => !customer.first_login,
  },
  {
    day: 7,
    action: "feature_introduction",
    condition: () => customer.feature_usage < 3,
  },
  {
    day: 14,
    action: "upgrade_suggestion",
    condition: () => customer.plan === "free" && customer.usage > 80,
  },
  {
    day: 30,
    action: "feedback_request",
    condition: () => customer.engagement_score > 7,
  },
];

const currentStage = journeyStages.find(
  (stage) => stage.day === daysSinceSignup && stage.condition()
);

if (currentStage) {
  return {
    customer_id: customer.id,
    action: currentStage.action,
    metadata: {
      stage: currentStage.day,
      customer_score: customer.engagement_score,
    },
  };
}

return [];

Resultado: Retenção +25%, churn rate -15%.

Integrações Mais Úteis

1. Slack + Linear + GitHub

Workflow: Push no GitHub → Atualizar Linear → Notificar no Slack

2. Calendly + Notion + Gmail

Workflow: Reunião agendada → Criar página no Notion → Enviar prep email

3. Stripe + Airtable + PostHog

Workflow: Novo pagamento → Atualizar dashboard → Trigger evento analytics

Dicas Avançadas

1. Error Handling Robusto

// Try-catch em todos os nodes críticos
try {
  const result = await api.call();
  return { success: true, data: result };
} catch (error) {
  // Log do erro
  console.error("API Error:", error);

  // Retry logic
  if (error.status === 429) {
    await new Promise((resolve) => setTimeout(resolve, 5000));
    return await api.call(); // Retry
  }

  // Fallback
  return {
    success: false,
    error: error.message,
    fallback_data: getDefaultData(),
  };
}

2. Rate Limiting Inteligente

// Queue para APIs com rate limit
const queue = $node["Queue"].json || [];
const maxPerMinute = 60;
const now = Date.now();

// Limpar requests antigos
const recentRequests = queue.filter((req) => now - req.timestamp < 60000);

if (recentRequests.length >= maxPerMinute) {
  // Aguardar próximo slot
  const oldestRequest = Math.min(...recentRequests.map((r) => r.timestamp));
  const waitTime = 60000 - (now - oldestRequest);

  return {
    action: "wait",
    wait_time: waitTime,
    queue: recentRequests,
  };
}

// Adicionar à queue e executar
recentRequests.push({ timestamp: now });
return {
  action: "execute",
  queue: recentRequests,
};

3. Data Validation

// Schema validation
const schema = {
  required: ["email", "name"],
  types: {
    email: "string",
    name: "string",
    age: "number",
  },
  formats: {
    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
  },
};

const validateData = (data, schema) => {
  const errors = [];

  // Check required fields
  schema.required.forEach((field) => {
    if (!data[field]) {
      errors.push(`Missing required field: ${field}`);
    }
  });

  // Check types and formats
  Object.entries(data).forEach(([key, value]) => {
    if (schema.types[key] && typeof value !== schema.types[key]) {
      errors.push(`Invalid type for ${key}: expected ${schema.types[key]}`);
    }

    if (schema.formats[key] && !schema.formats[key].test(value)) {
      errors.push(`Invalid format for ${key}`);
    }
  });

  return {
    valid: errors.length === 0,
    errors,
  };
};

Monitoramento e Debug

1. Logging Estruturado

const logger = {
  info: (message, data = {}) => {
    console.log(
      JSON.stringify({
        level: "info",
        timestamp: new Date().toISOString(),
        workflow: $workflow.name,
        node: $node.name,
        message,
        data,
      })
    );
  },

  error: (message, error = {}) => {
    console.error(
      JSON.stringify({
        level: "error",
        timestamp: new Date().toISOString(),
        workflow: $workflow.name,
        node: $node.name,
        message,
        error: {
          message: error.message,
          stack: error.stack,
        },
      })
    );
  },
};

// Uso
logger.info("Processing customer data", { customer_id: customer.id });

2. Health Checks

// Workflow de health check que roda a cada 5min
const endpoints = [
  "https://api.service1.com/health",
  "https://api.service2.com/health",
  "https://database.example.com/ping",
];

const results = await Promise.allSettled(endpoints.map((url) => fetch(url)));

const failures = results
  .map((result, index) => ({ url: endpoints[index], result }))
  .filter(({ result }) => result.status === "rejected")
  .map(({ url, result }) => ({ url, error: result.reason }));

if (failures.length > 0) {
  // Alert via Slack/Email
  return {
    alert: true,
    failures,
    message: `${failures.length} services down`,
  };
}

return { status: "all_healthy" };

Resultados Mensurados

Após 6 meses usando n8n:

• 4 horas/dia economizadas em tarefas manuais
• 95% redução em erros de processo
• 100+ workflows ativos
• Zero downtime dos workflows críticos

Próximos Passos

1. Machine Learning integration com workflows
2. Custom nodes para APIs específicas
3. Workflow templates reutilizáveis
4. Advanced scheduling baseado em eventos

Conclusão

n8n transformou completamente como trabalho. A capacidade de conectar qualquer coisa com qualquer coisa abriu possibilidades infinitas de automação.

Dica final: Comece pequeno, automatize uma tarefa por vez. O ROI aparece rápido!

---

Que processo você gostaria de automatizar? Tem alguma dúvida sobre n8n? Compartilhe nos comentários!