> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/conceitos/skail-for-geek/execucao-duravel.md).

# Execução durável

Na skail, **execução durável** é a capacidade de executar a lógica da sua aplicação com continuidade, consistência e segurança, mesmo quando há falhas, reinícios do processo ou esperas longas.

A ideia é simples: **você programa como sempre programou,** com métodos assíncronos, injeção de dependência e chamadas entre serviços. A skail assume a responsabilidade de **registrar o progresso da execução**, **preservar resultados já concluídos** e **retomar do ponto correto quando necessário**.

Em vez de exigir que o desenvolvedor controle manualmente estado temporário, tentativas, retomadas ou recuperação após falhas, a plataforma cuida dessa camada de execução por trás do código da solução.

### O que isso significa na prática

* Se a aplicação reiniciar no meio de um processamento, a execução não precisa começar do zero.
* Se uma etapa já foi concluída com sucesso, a skail evita repetição indevida.
* Se existir uma espera de tempo ou dependência de um evento externo, a execução pode ser retomada depois sem manter recursos presos desnecessariamente.
* Se houver falhas transitórias de comunicação, a plataforma aplica políticas de recuperação de forma controlada.

### Como isso aparece no código

No projeto, esse modelo aparece de forma natural:

* Métodos marcados com `[SkailFunction]` coordenam a sequência da lógica de negócio.
* Métodos marcados com `[SkailCommand]` executam operações externas ou não determinísticas, como acesso a banco, APIs, mensageria, geração de identificadores ou leitura de tempo atual.
* O desenvolvedor continua trabalhando com `async` e `await`, enquanto a skail cuida da durabilidade da execução.

```csharp
public class EmissaoService
{
    [SkailFunction]
    public async SkailTask Emitir(Guid id)
    {
        var cliente = await BuscarCliente(id);
        await GerarDocumento(cliente);
        await NotificarConclusao(id);
    }

    [SkailCommand]
    private async SkailTask<Cliente> BuscarCliente(Guid id)
    {
        return await _repositorio.ObterAsync(id);
    }

    [SkailCommand]
    private async SkailTask GerarDocumento(Cliente cliente)
    {
        await _integracao.EnviarAsync(cliente);
    }

    [SkailCommand]
    private async SkailTask NotificarConclusao(Guid id)
    {
        await _mensageria.PublicarAsync(id);
    }
}
```

### Regra prática para aplicar na solução

Uma forma simples de pensar no uso da skail é:

* Se o método **coordena a lógica** da sua aplicação, ele fica em `[SkailFunction]`.
* Se o método **fala com o mundo externo** ou depende de algo que pode variar entre execuções, ele fica em `[SkailCommand]`.

Essa separação permite que a plataforma saiba exatamente o que precisa registrar, reaproveitar e retomar.

### O que a skail cuida para você

* Persistência do progresso da execução.
* Retomada segura após falhas ou reinícios.
* Reaproveitamento de resultados já concluídos.
* Tentativas automáticas em falhas transitórias.
* Integração com sidecar para persistência, mensageria e observabilidade.

### Quando isso gera valor na solução

Execução durável faz diferença principalmente quando a sua aplicação:

* depende de integrações externas;
* atravessa indisponibilidades temporárias;
* precisa esperar confirmações assíncronas;
* não pode perder progresso no meio do processamento;
* precisa evitar duplicidade em etapas críticas.

### Em uma frase

**Com a skail, o desenvolvedor continua escrevendo a lógica da aplicação de forma natural, enquanto a plataforma assume a responsabilidade por preservar progresso, retomar execuções e manter consistência operacional.**