Automação é uma palavra que costuma chegar vestida de eficiência.
Mas, quando a trazemos para algo aparentemente banal — como uma lista de tarefas — ela revela outra coisa: estrutura.

Um “to-do” não é só um checklist.
É um sistema mínimo de decisão: capturar, priorizar, executar, registrar.

O n8n, por ser um orquestrador de fluxos, é um bom laboratório para isso. Ele não é um app de tarefas. É um motor. E motores exigem desenho.

Este post constrói um sistema de tarefas no n8n com:

• API própria (via Webhook)
• Persistência em banco (SQLite ou Postgres)
• Estados (pendente, fazendo, concluída)
• Atualização e listagem
• Estrutura pronta para evoluir (prioridade, tags, notificações)

Sem promessas de produtividade transcendental.
Apenas arquitetura.

1. Arquitetura do sistema

Vamos desenhar algo simples e extensível:

Fluxos principais:

1. Criar tarefa
2. Listar tarefas
3. Atualizar status
4. Deletar tarefa

Camadas:

• Entrada: Webhook HTTP
• Processamento: Nodes (Set, IF, Switch)
• Persistência: Banco relacional
• Saída: JSON estruturado

2. Estrutura do banco

Você pode usar:

• SQLite (local)
• Postgres (produção)

Tabela base

CREATE TABLE tasks (
  id SERIAL PRIMARY KEY,
  title TEXT NOT NULL,
  description TEXT,
  status TEXT DEFAULT 'pending',
  priority INTEGER DEFAULT 3,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Estados possíveis

• pending
• doing
• done

Evite booleanos para status.
Sistemas simples morrem quando crescem.

3. Workflow 1 — Criar tarefa

Node 1: Webhook

• Método: POST
• Path: /tasks
• Response: Last node

Payload esperado:

{
  "title": "Estudar modelo de Poisson",
  "description": "Revisar hipótese de independência",
  "priority": 2
}

Node 2: Set

Validar campos mínimos:

• title obrigatório
• status default = pending
• priority default = 3

Node 3: IF (validação)

Se title estiver vazio → retornar erro.

Node 4: Postgres (ou SQLite)

Operação: Insert

Campos mapeados:

• title
• description
• status
• priority

Node 5: Respond to Webhook

Retorno:

{
  "message": "Task created",
  "task_id": 17
}

4. Workflow 2 — Listar tarefas

Webhook GET /tasks

Node Postgres:

SELECT * FROM tasks
ORDER BY 
  CASE status
    WHEN 'doing' THEN 1
    WHEN 'pending' THEN 2
    WHEN 'done' THEN 3
  END,
priority ASC,
created_at DESC;

Retorno JSON estruturado.

Aqui já existe uma decisão silenciosa:
ordenar é priorizar.

5. Workflow 3 — Atualizar status

Webhook PATCH /tasks/:id

Payload:

{
  "status": "done"
}

Node:

UPDATE tasks
SET status = {{$json.status}},
    updated_at = CURRENT_TIMESTAMP
WHERE id = {{$json.id}};

6. Workflow 4 — Deletar tarefa

Webhook DELETE /tasks/:id

DELETE FROM tasks WHERE id = {{$json.id}};

7. Melhorias estruturais

Agora começa a parte interessante.

Um sistema de tarefas vira sistema de decisão quando você adiciona:

1. Prioridade adaptativa

• Aumentar prioridade automaticamente se tarefa ficar > 7 dias pendente.

2. Notificações

Node:

• Telegram
• Email
• Slack

Se tarefa mudar para “doing” → notificar.

3. Agendamento

Node Cron:

• Executar todo dia às 8h
• Listar pendentes
• Enviar resumo

8. Exemplo de fluxo completo (estrutura mental)

Webhook → Set → IF → DB → Respond
Cron → DB → Loop → Telegram
Webhook PATCH → DB → IF → Notification

O n8n vira uma engrenagem silenciosa.

9. Versionamento e ambiente

Se for usar em produção:

• Use Docker
• Use Postgres externo
• Ative autenticação básica
• Proteja Webhooks

Exemplo Docker básico:

version: '3'

services:
  n8n:
    image: n8nio/n8n
    ports:
      - 5678:5678
    environment:
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=senha

10. O ponto menos técnico

Um “to-do” automatizado revela algo curioso:

Quando a tarefa vira registro,
ela deixa de ser culpa.

Ela vira dado.

E dados são manipuláveis.

Talvez seja por isso que sistemas bem desenhados dão paz.
Eles tiram as tarefas do campo emocional e colocam no campo estrutural.

E estrutura é uma forma discreta de liberdade.