---
title: "ShipReal: De vibe coder a engenheiro de verdade"
description: "Sua AI escreveu o app. Ninguém escreveu a parte que o mantém no ar. Este curso de 20 horas fecha essa lacuna."
canonical: "https://shipreal.dev/pt-br"
last-updated: "2026-09-01"
---

# De vibe coder a engenheiro de verdade

> Sua AI escreveu o app. Ninguém escreveu a parte que o mantém no ar. Este curso de 20 horas fecha essa lacuna.

**38 módulos, postmortems reais, exercícios práticos e quizzes autocorrigidos.** [YouTube](https://www.youtube.com/watch?v=fyHbx9de3GI&list=PLFEcqBh9-Xwo) · [Teachable](https://shipreal.teachable.com/courses/course/lectures/66619411)

## Conteúdo do curso

### Introdução

O seu mapa do curso inteiro: o que cada módulo de aprofundamento entrega e como as onze partes se apoiam umas nas outras.

- **Introdução: a estrada à frente** (13 aulas, ~25 min): O mapa na mesa: os 38 módulos, o que cada mergulho a fundo entrega e para qual módulo pular quando algo quebra.

### Parte 1: A virada de mentalidade

Reprograme o jeito como você pensa software que funciona: sistemas, estado e trade-offs. A camada de critério que a AI não fornece.

- **A ilusão do 'funciona'** (12 aulas, ~28 min): O ciclo de vida da requisição, os ambientes e o iceberg da produção: por que 'roda no meu laptop' não significa quase nada.
- **Pensar em sistemas e estado** (12 aulas, ~29 min): Estado, efeitos colaterais e idempotência: por que 'roda de novo' às vezes piora as coisas.
- **Decisões, complexidade e abstração** (14 aulas, ~36 min): Trade-offs, YAGNI e quando uma abstração paga o aluguel: as decisões de critério que a AI não toma por você.

### Parte 2: A base do desenvolvedor

O ofício do dia a dia: Git como ferramenta de pensar, um workflow AI-native, runtimes, algoritmos, arquitetura frontend e o campo minado das dependências.

- **Controle de versão como ferramenta de pensar** (13 aulas, ~33 min): Git além de commit e push: estratégia de branch, bisect e blame como arqueologia.
- **O fluxo de engenharia AI-native** (13 aulas, ~31 min): O prompt como escrita de especificação, revisar código que você não escreveu e os guardrails que tornam segura a velocidade da AI.
- **Como o código roda: a camada do runtime** (13 aulas, ~33 min): Processos, memória e o event loop: por que o Node trava e por que o GIL do Python importa.
- **Pensamento algorítmico: complexidade e estruturas de dados** (13 aulas, ~27 min): Intuição de Big-O e arrays vs maps vs árvores: quando o N ao quadrado te mata em silêncio com 10.000 usuários.
- **Arquitetura frontend: o que a AI constrói para você (e o que ela erra)** (13 aulas, ~35 min): Modelos de renderização, gestão de estado e as partes do seu frontend que a AI monta errado.
- **Gestão de dependências: o campo minado escondido** (12 aulas, ~31 min): Lockfiles, as mentiras do semver e ataques à cadeia de suprimentos: a história do left-pad e como não estrelar a sequência.

### Parte 3: A camada de dados

Bancos de dados como modelos mentais: tabelas e índices antes das consultas, SQL sem medo e migrações que não derrubam a produção.

- **Fundamentos de banco de dados: pensar em dados** (13 aulas, ~33 min): Pensar em tabelas, índices e constraints antes de escrever uma única consulta.
- **SQL e pensar em consultas** (13 aulas, ~33 min): Joins sem medo, query plans que você consegue ler de verdade e as consultas que derretem em escala.
- **Dados em escala: mutações, migrações e além** (13 aulas, ~34 min): Mutações, migrações e backfills que não levam a produção junto.

### Parte 4: Redes e contratos

Como os sistemas conversam: APIs como contratos, a corrente do DNS ao HTTP em que toda requisição vive e padrões de tempo real.

- **Design de API como contrato** (13 aulas, ~35 min): Pensar em REST vs RPC, versionar e evoluir APIs sem quebrar quem depende delas.
- **Fundamentos de redes** (12 aulas, ~33 min): DNS, TCP, TLS, HTTP: a corrente em que toda requisição vive ou morre.
- **Padrões real-time e event-driven** (12 aulas, ~33 min): WebSockets, server-sent events e fluxos orientados a eventos: para quando o polling deixa de bastar.

### Parte 5: Fortificação

Fazer sobreviver ao contato com a realidade: segurança por padrão, tratamento de erros resiliente, testes que compram confiança e observabilidade que responde 'o que quebrou às 3 da manhã'.

- **Segurança por padrão** (12 aulas, ~35 min): Os principais riscos do OWASP, injeção e falhas de auth: os ataques que encontram você, não o contrário.
- **Tratamento de erros e resiliência** (12 aulas, ~32 min): Timeouts, retries com backoff e circuit breakers: falhar com elegância em vez de aos berros.
- **Testes: confiança, não cobertura** (12 aulas, ~33 min): Testes que compram confiança em vez de números de cobertura: o que testar, o que pular e por quê.
- **Observabilidade: logs, métricas e traces** (15 aulas, ~33 min): Logs, métricas e traces que respondem 'o que quebrou às 3 da manhã' antes dos seus usuários.

### Parte 6: Infraestrutura e deploy

Sobre o que o seu código se apoia: o que os containers resolvem de verdade, conceitos de nuvem que sobrevivem a qualquer redesign de console e pipelines que barram deploys ruins.

- **Containers: o porquê, não o como** (12 aulas, ~35 min): O que o Docker resolve de verdade: imagens vs containers, e por que 'funciona no container' finalmente significa algo.
- **Infraestrutura em nuvem: conceitos, não cliques no console** (12 aulas, ~38 min): A árvore de decisão dos serviços gerenciados: conceitos de nuvem que sobrevivem a qualquer redesign de console.
- **CI/CD: o pipeline que te protege** (12 aulas, ~33 min): O pipeline que barra deploys ruins antes que os seus usuários os encontrem.

### Parte 7: Arquitetura e escala

Projetar para crescer: arquitetura monolith-first, filas, cache, fazer profiling antes de otimizar e intuição de sistemas distribuídos.

- **Padrões de arquitetura: monolitos, serviços e o meio-termo** (13 aulas, ~34 min): Pensar monolito primeiro, quando os serviços merecem a complexidade que custam e o meio-termo que ninguém vende.
- **Processamento assíncrono e filas** (14 aulas, ~34 min): Filas de mensagens: por que todo sistema real tem uma e o que acontece quando os consumers ficam para trás.
- **Estratégias de cache** (12 aulas, ~30 min): Redis, TTLs e invalidação de cache: notoriamente um dos dois problemas difíceis da computação.
- **Performance, profiling e escalonamento** (14 aulas, ~33 min): Faça profiling antes de otimizar: achar o gargalo real em vez do que você chutou.
- **Intuição de sistemas distribuídos** (12 aulas, ~34 min): As falácias da computação distribuída, e a intuição para achá-las no seu próprio design.

### Parte 8: A camada de negócio

O código que paga as contas: pagamentos e compliance, métricas que de fato preveem receita e atribuição sem mentir para si mesmo.

- **Pagamentos, assinaturas e compliance** (12 aulas, ~34 min): Webhooks de pagamento que sobrevivem a retries, máquinas de estado de assinatura e o básico de compliance que não dá para pular.
- **Métricas de negócio e product analytics** (13 aulas, ~35 min): As métricas que de fato preveem receita, e as de vaidade que não preveem.
- **Aquisição de usuários, anúncios e atribuição** (13 aulas, ~36 min): UTMs, janelas de atribuição e a matemática de anúncios sem mentir para si mesmo.

### Parte 9: Produtos movidos a AI

Colocar inteligência no ar com responsabilidade: como os modelos aprendem, embeddings e RAG, e features de AI em produção com evals e orçamento de custo.

- **Fundamentos de machine learning: como os modelos aprendem** (12 aulas, ~33 min): Como os modelos aprendem de verdade: o suficiente para não cair em demo nem em vendedor.
- **Colocando inteligência no seu app** (13 aulas, ~33 min): Embeddings, RAG e escolher o modelo certo para a tarefa em vez do mais barulhento.
- **Construir features de AI para produção** (12 aulas, ~33 min): Evals, orçamentos de custo e latência, e features de LLM que sobrevivem a usuários reais.

### Parte 10: Ofício e domínio de produção

Os hábitos de sênior: debugging guiado por hipótese e o checklist de entrada no ar que separa lançamento de aposta.

- **Debugging como disciplina** (12 aulas, ~35 min): Debugging guiado por hipótese: reproduzir, isolar, provar, não print e reza.
- **Prontidão para produção e operação contínua** (14 aulas, ~37 min): O checklist de entrada no ar, a resposta a incidentes e o ritmo de operação que começa depois do lançamento.

### Parte 11: Expansão para o mobile

No celular tudo muda: dados offline-first, redes que somem no meio da requisição e os trens de release das app stores.

- **Modelos mentais próprios do mobile** (13 aulas, ~33 min): Por que mobile não é um site pequeno: ciclos de vida, permissões e o SO como um locador severo.
- **Dados e rede no mobile** (12 aulas, ~37 min): Dados offline-first, conflitos de sincronização e redes que somem no meio da requisição.
- **Release e distribuição mobile** (12 aulas, ~30 min): Review das app stores, trens de release e por que não dá para dar hotfix em um binário.

### Despedida: A despedida

O fecho do curso: o que mudou no seu jeito de pensar e a única coisa a fazer enquanto ainda está fresco.

- **A despedida: agora vá colocar no ar algo que aguente** (7 aulas, ~12 min): O que mudou no seu jeito de pensar, a única coisa a fazer esta semana e como manter o critério que você acabou de construir.

## Perguntas frequentes

### Para quem é este curso?

Desenvolvedores que aprenderam construindo, não estudando. Você sobe apps com ferramentas de AI todo dia (Copilot, Claude, ChatGPT) e está mais rápido do que nunca. Mas existe uma distância entre "roda" e "é engenharia", e você sente isso quando algo quebra às 3 da manhã ou quando um dev sênior pergunta "por que você fez assim?"

Você não é iniciante. Sabe escrever código, mas nem sempre sabe explicar o que acontece depois de apertar Enter. É exatamente essa a distância que este curso fecha.

### O que ele ensina que eu não consigo pedir num prompt?

Critério. Hoje a AI escreve 80% do seu código; os 20% que importam são arquitetura, tratamento de erros, modelo de segurança e projeto do sistema. Esses 20% exigem entender trade-offs, contexto e consequências, que é justamente o que a AI não faz por você.

Cada módulo pega algo que você já "sabe" (bancos de dados, APIs, deploys) e mostra o que está faltando: o ciclo de vida da requisição, os planos de consulta, as tempestades de retry, a invalidação de cache, o checklist de entrada no ar.

### Preciso de diploma em CS ou de uma stack específica?

Nenhum diploma é necessário. O curso foi feito para quem pulou essa etapa, ou tem o diploma e esqueceu a maior parte. Ele começa pelo conceito: os exemplos usam ferramentas mainstream como PostgreSQL, Redis, Docker e Stripe, mas cada módulo ensina o modelo mental, não a clicar nos botões de um fornecedor, então vale para qualquer stack que você usar para subir para produção.

### O que são os postmortems e os exercícios?

Cada módulo do Complete disseca um desastre de engenharia real e documentado: empresa real, data real, causa raiz real, e o que teria evitado. Depois o exercício aplica o módulo ao seu próprio projeto já no ar, não a um repo de brinquedo, então cada módulo termina com o seu sistema real um pouco mais pronto para produção do que antes.

### Quanto tempo vai levar?

O Complete são 38 módulos de 25 a 40 minutos cada, mais os exercícios, e fecha com uma despedida curta. Conte cerca de 20 horas de vídeo, e mais ou menos o dobro com a parte prática. É dividido em onze partes independentes, então você também pode pular direto para a parte que está pegando fogo agora: deploys quebrados? Parte 6. Consulta lenta? Parte 3.

### Recebo um certificado?

Sim! E ele é conquistado, não entregue por ter assistido: o certificado de conclusão ShipReal, emitido pela Teachable. Cada módulo fecha com um quiz autocorrigido de 10 perguntas e uma pergunta aberta, e o certificado vem quando você tiver passado por todos.

### Minha empresa pode comprar isso para a equipe inteira?

Sim. As vagas são vendidas direto, pelo preço por vaga dos planos para equipes acima, em uma nota só, e acompanham a equipe conforme as pessoas entram e saem. Cada engenheiro recebe o curso Complete, trabalhado no próprio projeto e não em um sandbox compartilhado.

Acima de 20 vagas, ou quando você precisa de PO, single sign-on por SAML ou OIDC, ou os módulos entregues no seu próprio LMS como pacotes SCORM ou xAPI ou por LTI, dentro do Cornerstone, Workday, Moodle ou do que a sua empresa usar, escreva para mim e a gente dimensiona junto.

### E se não for para mim?

Comece pelas visões gerais gratuitas no YouTube: elas dizem rápido se o curso fala a sua língua. Além disso, a garantia na tabela de preços é a resposta inteira, e como acioná-la está na política de reembolso.

### Em quais idiomas ele está disponível?

Por enquanto a narração é só em inglês. O Complete na Teachable inclui legendas em inglês, francês, alemão, italiano, espanhol & hebraico. Em breve, mais idiomas.

## Legal

[Privacy Policy](https://shipreal.dev/privacy) · [Terms of Service](https://shipreal.dev/terms) · [Refund Policy](https://shipreal.dev/refunds)