Vertical Slices em .NET: features de ponta a ponta

Por que organizar o código por features e não por camadas

Muitas codebases em .NET ainda organizam o projeto por camadas (API, Application, Domain, Infrastructure). Embora funcione bem, essa abordagem pode diluir a coesão de features, espalhando regras de negócio por múltiplas pastas e aumentando o atrito para evoluir com segurança.

Vertical Slice Architecture propõe organizar o código por features de ponta a ponta (request → handler → domínio → persistência), reduzindo acoplamento entre features, melhorando a legibilidade e favorecendo evolução incremental. Este artigo mostra como aplicar vertical slices em .NET de forma pragmática, sem descartar seus padrões preferidos (DDD, CQRS, MediatR, Minimal APIs).

Conceitos de Vertical Slice Architecture

Vertical Slice: agrupamento de todos os artefatos necessários para uma feature específica em um único “fatiamento” vertical (contratos, handler, validações, casos de uso, persistência).
Foco em features: cada slice é dono do seu fluxo — da entrada HTTP até o domínio e a infraestrutura relacionada.
Independência: slices minimizam dependências entre si; alterações em uma feature raramente impactam outras.
Compatibilidade: funciona com CQRS (Commands/Queries), MediatR (ou sem), FluentValidation, EF Core (com DbContext por módulo/slice, se fizer sentido), Minimal APIs ou Controllers.
Objetivo: coerência local > “pureza” arquitetural. Otimize a rotina do desenvolvedor e a clareza para manutenção.

Arquitetura por features com Vertical Slices

Em vez de agrupar por camadas globais, organizamos por features. Exemplo de estrutura:

Chaves da abordagem

Pontos de entrada por feature: cada slice publica seus endpoints.
Casos de uso explícitos (Commands/Queries) por slice.
Validações e mapeamentos locais à feature.
Dependências invertidas: slices dependem de abstrações de domínio e portas; infraestrutura as implementa.
Observabilidade: métricas/logs/traces nomeados por feature facilitam troubleshooting.

Dica: você pode iniciar em monólito modular e evoluir slices críticos para microservices no futuro, se necessário — o design já prepara a extração.

Vertical Slices em .NET com Minimal APIs, MediatR e EF Core

A seguir, um recorte CRUD mínimo de Customers com Minimal APIs + MediatR + FluentValidation + EF Core (padrão ilustrativo; adapte a seus utilitários).

5.1. Endpoint (Create)

5.2. Contrato e Validação

5.3. Handler (Caso de Uso)

5.4. Bootstrap (Program.cs)

5.5. Consulta (GetById) — Outro Slice da Mesma Feature

Note como cada slice envelope seu fluxo completo: DTO/Command/Query, validação (quando há entrada), handler, mappings e endpoints.

Boas práticas e pontos de atenção em Vertical Slices

Corte por feature, não por camada: mantenha coeso o que muda junto.
Nomeie pelo caso de uso: CreateCustomer, ApproveOrder, ShipOrder. Isso facilita rastreabilidade e logs.
Encapsule validações próximas à entrada da feature.
Evite “pastas utilitárias” genéricas que quebram a coesão do slice.
Camada de domínio enxuta e estável: entidades/VOs e regras que sobrevivem às features.
Observabilidade por slice: métricas e traces com nomes que reflitam o caso de uso (ex.: customers.create.duration).
EF Core: considere DbContext modular (um por módulo/grupo de slices) para reduzir colisões de migrações.
Transversal sem acoplamento: middlewares, behaviors (ex.: MediatR Pipeline Behaviors) para auditoria, validação e idempotência sem poluir handlers.

Quando usar Vertical Slices e quando adiar

Use Vertical Slices quando

a equipe quer acelerar a entrega de features com autonomia e menor impacto colateral;
o domínio é grande e muda frequentemente;
há necessidade de testabilidade localizada (testes de caso de uso sem navegar por camadas globais);
você deseja preparar o terreno para extração futura de módulos ou microservices críticos.

Evite (ou adie) quando

o sistema é muito pequeno e a complexidade não se paga;
o time ainda está aprendendo o domínio; começar pelo monólito modular pode ser mais simples.
não há disciplina de padronização mínima (nomenclatura, pastas, convenções de endpoint/handler), o que pode levar a “cada slice de um jeito”.

Vertical Slices: features como unidades de primeira classe

Vertical Slices tornam as features unidades de primeira classe, reduzindo o atrito para evoluir o software. Ao agrupar request, validação, caso de uso, domínio e persistência por feature, você ganha clareza, isolamento e previsibilidade. Comece aplicando em uma área do sistema e avalie: o retorno é rápido, especialmente em bases com alto ritmo de mudança. Em cenários .NET modernos, combinar Minimal APIs + MediatR + FluentValidation + EF Core entrega uma experiência direta e robusta.

Vertical Slices em .NET: Estruturando Features de Ponta a Ponta