Fluxos de Automação Empresarial com Zapier, Airflow e Power Automate

Introdução

A transformação digital não se resume apenas a migrar dados para a nuvem ou adotar novos dispositivos. O verdadeiro diferencial competitivo está na automação de processos empresariais: eliminar tarefas manuais, reduzir erros e liberar a equipe para atividades de maior valor.

Neste artigo, vamos explorar como combinar três ferramentas populares — Zapier, Apache Airflow e Microsoft Power Automate — para criar fluxos end‑to‑end que conectam sistemas legados, aplicativos SaaS e usuários finais. Você verá a lógica de modelagem, receberá códigos prontos para copiar/colar e entenderá como monitorar cada etapa.

Objetivo: ao final da leitura, você será capaz de projetar, implementar e operar um fluxo de aprovação de compra que envolve captura de formulário, validação automática, enriquecimento de dados e notificação em tempo real.

Por que automatizar processos?

Benefício	Impacto no negócio
Velocidade	Redução de tempo de ciclo em até 70 %
Precisão	Diminuição de erros humanos críticos
Visibilidade	Dados de auditoria em tempo real
Escalabilidade	Capacidade de replicar o fluxo em novos departamentos
Custo	Economia de horas‑homem e diminuição de retrabalho

Esses ganhos são ainda mais evidentes quando a automação interliga diferentes plataformas — por exemplo, um formulário web que dispara um job de ETL, que por sua vez aciona uma mensagem no Teams. A orquestração correta evita “silos” e garante que a informação flua de forma consistente.

Ferramentas low‑code e open source para fluxos integrados

Zapier

Zapier é um serviço de integração no‑code que permite conectar mais de 5 000 aplicativos por meio de “Zaps” (gatilho + ação). Ideal para tarefas rápidas, como:

• Receber um e‑mail e criar um registro em um CRM.
• Capturar dados de um Google Form e enviá‑los para uma planilha.
• Disparar um webhook quando um evento ocorre em um SaaS.

Apache Airflow

Airflow é um orquestrador open source escrito em Python. Ele permite definir DAGs (Directed Acyclic Graphs) que descrevem dependências entre tarefas, agendar execuções e monitorar resultados via UI. É a escolha certa quando:

• É necessário executar jobs de ETL ou scripts de validação.
• O fluxo possui lógica condicional complexa.
• Há necessidade de reprocessamento ou back‑fill de dados históricos.

Microsoft Power Automate

Power Automate (antes Microsoft Flow) oferece recursos low‑code integrados ao ecossistema Microsoft (Teams, SharePoint, Dynamics). Ele suporta:

• Conectores nativos (Outlook, SQL Server, Azure).
• Criação de fluxos baseados em eventos (quando um item é criado, quando um e‑mail chega).
• Execução de expressões avançadas usando a linguagem Workflow Definition Language (WDL).

Modelando um fluxo de aprovação de compra

Antes de codificar, vamos desenhar o processo usando BPMN (Business Process Model and Notation). O diagrama abaixo descreve as etapas principais:

Solicitação – O colaborador preenche um Google Form com detalhes da compra.

Webhook Zapier – O Zap captura o formulário e envia um payload JSON para um endpoint do Airflow.

DAG Airflow – Executa validações (valor máximo, fornecedor autorizado) e grava a solicitação em um banco PostgreSQL.

Power Automate – Detecta a nova linha no banco e envia uma aprovação ao Microsoft Teams.

Decisão – O gestor aprova ou rejeita. A resposta atualiza o registro e dispara um e‑mail ao solicitante.

Representação simplificada (texto)

[Google Form] → (Zapier webhook) → [Airflow DAG] → (PostgreSQL) → (Power Automate)

                ↘                                   ↙
               (Validação)                     (Notificação Teams)

Implementação passo a passo

1. Configurando o Zapier

Crie um novo Zap com Trigger “New Form Response in Google Forms”.

No passo de Action, escolha “Webhooks by Zapier – POST”.

Defina a URL do endpoint do Airflow (veremos abaixo) e o payload:

{

  "request_id": "{{response_id}}",
  "employee": "{{answers[0]}}",
  "amount": "{{answers[1]}}",
  "vendor": "{{answers[2]}}",
  "description": "{{answers[3]}}"
}

Dica: habilite “Wrap request in JSON” e marque “Send as JSON”.

2. Criando a DAG no Apache Airflow

Salve o arquivo abaixo em /dags/purchase_approval.py.

# purchase_approval.py

from datetime import datetime, timedelta
import json
import logging
import psycopg2
from airflow import DAG
from airflow.operators.http_operator import SimpleHttpOperator
from airflow.operators.python_operator import PythonOperator

-------------------------------------------------
Configurações
-------------------------------------------------

POSTGRES_CONN = {
    "host": "postgres.example.com",
    "port": 5432,
    "dbname": "company",
    "user": "airflow",
    "password": "secure_password"
}
MAX_AMOUNT = 5000  # Valor máximo sem revisão adicional

-------------------------------------------------
Funções auxiliares
-------------------------------------------------

def validate_payload(context):
    payload = context["ti"].xcom_pull(task_ids="receive_webhook")
    data = json.loads(payload)
    amount = float(data["amount"])
    if amount > MAX_AMOUNT:
        raise ValueError(f"Valor {amount} excede o limite de {MAX_AMOUNT}")
    logging.info("Payload validado com sucesso")
    return json.dumps(data)  # Passa adiante


def insert_into_db(context):
    payload = context["ti"].xcom_pull(task_ids="validate")
    data = json.loads(payload)


    conn = psycopg2.connect(POSTGRES_CONN)
    cur = conn.cursor()
    insert_sql = """
        INSERT INTO purchase_requests (request_id, employee, amount, vendor, description, status)
        VALUES (%s, %s, %s, %s, %s, %s)
    """
    cur.execute(insert_sql, (
        data["request_id"],
        data["employee"],
        data["amount"],
        data["vendor"],
        data["description"],
        "PENDING"
    ))
    conn.commit()
    cur.close()
    conn.close()
    logging.info("Registro inserido no PostgreSQL")

-------------------------------------------------
Definição da DAG
-------------------------------------------------

default_args = {
    "owner": "automation",
    "depends_on_past": False,
    "start_date": datetime(2024, 1, 1),
    "retries": 1,
    "retry_delay": timedelta(minutes=5),
}


with DAG(
    dag_id="purchase_approval",
    default_args=default_args,
    schedule_interval=None,  # Executa sob demanda via webhook
    catchup=False,
) as dag:


    receive_webhook = SimpleHttpOperator(
        task_id="receive_webhook",
        http_conn_id="zapier_webhook",  # Configurado no UI > Connections
        endpoint="/webhook",
        method="POST",
        data="{{ dag_run.conf }}",  # Recebe payload do Zapier
        headers={"Content-Type": "application/json"},
        response_check=lambda response: response.status_code == 200,
    )


    validate = PythonOperator(
        task_id="validate",
        python_callable=validate_payload,
        provide_context=True,
    )


    store = PythonOperator(
        task_id="store",
        python_callable=insert_into_db,
        provide_context=True,
    )


    receive_webhook >> validate >> store

Como funciona:

• O SimpleHttpOperator recebe o JSON enviado pelo Zapier.
• validate_payload verifica se o valor está dentro do limite.
• insert_into_db grava a solicitação na tabela purchase_requests.
• A DAG tem schedule_interval=None, ou seja, só roda quando o webhook dispara.

3. Power Automate – Aprovação no Teams

No portal Power Automate, crie um Automated cloud flow com trigger “When an item is created” (SQL Server ou PostgreSQL via conector “PostgreSQL”).

Selecione a tabela purchase_requests.

Adicione a ação Post a message (V3) – Microsoft Teams** com o conteúdo:

```json { "type": "message", "attachments": [ { "contentType": "application/vnd.microsoft.card.adaptive", "content": { "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", "type": "AdaptiveCard", "version": "1.4", "body": [ { "type": "TextBlock", "text": "🛒 Nova solicitação de compra", "weight": "Bolder", "size": "Medium" }, { "type": "FactSet", "facts": [ { "title":