# Como escolher um flow

O SDK público expõe quatro classes base para automações. A escolha certa depende menos do sistema de origem e mais de como você quer comparar, agrupar e publicar dados.

## Visão rápida

| Flow                          | Quando usar                                                | Pergunta-chave                                        |
| ----------------------------- | ---------------------------------------------------------- | ----------------------------------------------------- |
| `NoDeltaIntegrationFlow`      | envio unidirecional sem comparação de estado               | "eu só preciso ler e enviar?"                         |
| `NoDeltaBatchIntegrationFlow` | envio unidirecional em alto volume                         | "eu preciso processar em lotes?"                      |
| `DeltaIntegrationFlow`        | comparação de origem e destino com insert, update e delete | "eu preciso reconciliar estados?"                     |
| `BatchDeltaIntegrationFlow`   | delta com processamento em lote                            | "eu preciso reconciliar estados e agrupar operações?" |

## `NoDeltaIntegrationFlow`

Use quando a automação apenas lê uma origem e executa uma ação de saída, sem comparar snapshots anteriores.

Cenários comuns:

* envio de eventos para API externa;
* exportação simples para data lake;
* processamento disparado por payload de webhook.

## `NoDeltaBatchIntegrationFlow`

Use quando o cenário continua sendo unidirecional, mas o volume pede agrupamento para reduzir custo, chamadas externas ou tempo de processamento.

Esse flow costuma fazer sentido quando:

* o destino aceita operações em lote;
* o custo por request é relevante;
* o volume por execução é alto.

## `DeltaIntegrationFlow`

Use quando a automação precisa comparar origem e destino para decidir entre:

* insert;
* update;
* delete.

Esse é o flow certo para sincronizações clássicas entre sistemas com reconciliação de estado.

Geralmente, ele pede uma modelagem clara de:

* `keyFields` para identidade do registro;
* `deltaFields` para comparação de mudança;
* ações de insert, update e delete.

## `BatchDeltaIntegrationFlow`

Use quando o cenário é delta, mas o volume exige batching.

Ele combina a lógica de reconciliação com operações agrupadas no destino, o que costuma ser útil em integrações com:

* APIs bulk;
* pipelines analíticos;
* sistemas com custo alto por operação individual.

## Regras práticas de decisão

* se não existe comparação entre origem e destino, comece por **No delta**;
* se existe comparação, comece por **Delta**;
* só vá para as versões **batch** quando houver ganho claro de volume, custo ou throughput;
* não escolha batch apenas por antecipação: a implementação e o troubleshooting tendem a ficar mais complexos.

## Exemplos de cenários

* **Webhook que recebe nota emitida e grava em banco**: `NoDeltaIntegrationFlow`
* **Exportação diária de pedidos para lake**: `NoDeltaBatchIntegrationFlow`
* **Sincronização de usuários entre HR e ERP**: `DeltaIntegrationFlow`
* **Sincronização massiva de catálogo entre duas bases**: `BatchDeltaIntegrationFlow`

## Depois da escolha

Depois de escolher o flow:

1. modele `defineMetadata()` com foco no monitoramento;
2. externalize parâmetros e sistemas no produto;
3. valide se precisa de Tabelas De/Para ou Sequências;
4. planeje build e deploy com `tunnelhub.yml`.

Consulte também [Fluxos de integração](https://docs.tunnelhub.io/sdk/integration-flows) e [Helpers de plataforma](https://docs.tunnelhub.io/sdk/platform-services).