Deploy Gratuito de um Projeto Full Stack em 10 Passos
Baixe aqui o arquivo e aprenda passo a passo como fazer o deploy gratuito com Render de um projeto MERN (MongoDB, Express, React, Node.js).
Neste artigo você vai aprender em 10 passos simples como realizar o deploy de um projeto completo usando a plataforma Render, mas que podem ser adaptados para outras plataformas como Heroku ou Vercel. Vamos direto ao ponto, com uma linguagem acessível e exemplos práticos!
Por que fazer o deploy de um projeto MERN?
Fazer o deploy de um projeto MERN permite que sua aplicação saia do ambiente local (localhost) e fique disponível online para qualquer pessoa acessar. Isso é essencial para demonstrar seu trabalho, testar em produção ou até compartilhar com clientes e recrutadores.
Para fazer o download do(s) arquivo(s) utilizados na aula, preencha com o seu e-mail:
Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.
Passo 1: Criar o Build do Frontend em React
O que é build e por que ele é necessário?
Chamamos de build o processo de transformar seu projeto React em arquivos estáticos (HTML, CSS e JavaScript) que podem ser servidos por um servidor. Sem isso, seu frontend não poderá ser acessado online.
No terminal, na pasta do frontend, execute:
npm run buildIsso vai criar uma pasta dist com os arquivos index.html, index.js e index.css. Esses arquivos são os que o servidor vai entregar aos usuários.

Dica: Certifique-se de que todas as dependências do frontend estão instaladas com npm install antes do build.
Passo 2: Servir o Frontend de Forma Estática
Como configurar o backend para servir o frontend?
No backend (Node.js com Express), você precisa configurar o servidor para entregar os arquivos estáticos gerados no build do React. Use o middleware express.static para isso.
Exemplo de código no arquivo principal do backend (server.js):
const express = require('express');
const path = require('path');
const app = express();
app.use(express.static(path.join(__dirname, '../frontend/dist')));Isso vai fazer com que a pasta dist do frontend seja servida como a rota padrão.
Dica: Use o módulo path do Node.js para criar caminhos corretos entre o backend e a pasta dist.
Passo 3: Criar uma Rota de Redirecionamento
Por que redirecionar rotas não mapeadas?
Em aplicações React, quando o usuário acessa uma rota não mapeada diretamente, o servidor deve redirecionar para o index.html para que o React Router gerencie a navegação.
Adicione esta rota no backend, após todas as outras rotas:
app.get('*', (req, res) => {
res.sendFile(path.join(__dirname, '../frontend/dist/index.html'));
});Isso garante que qualquer rota não reconhecida seja redirecionada para o frontend.
Passo 4: Organizar as Rotas da API no Backend
Como evitar conflitos entre rotas do frontend e backend?
Para evitar confusão entre as rotas do frontend e do backend, adicione um prefixo /api a todas as rotas do backend.
Por exemplo:
app.use('/api/users', userRoutes);
app.use('/api/places', placeRoutes);
app.use('/api/bookings', bookingRoutes);No frontend, atualize as chamadas à API para incluir o prefixo /api. Exemplo:
const baseURL = '/api';
fetch(`${baseURL}/users`);Dica: Consolidar o baseURL em uma variável facilita futuras alterações.
Passo 5: Diferenciar Ambientes (Development vs. Production)
Como configurar o frontend para diferentes ambientes?
Use variáveis de ambiente para definir a URL da API dependendo do ambiente (desenvolvimento ou produção). No arquivo principal do frontend (App.jsx), configure o baseURL com um operador ternário:
const baseURL = import.meta.env.MODE === 'development'
? 'http://localhost:4000/api'
: 'https://seu-dominio.com/api';Isso garante que o frontend se conecte à API correta em cada ambiente.
Passo 6: Automatizar Build e Start com Scripts
Como preparar o projeto para o deploy?
Crie um arquivo package.json na raiz do projeto para gerenciar os scripts de build e start. Exemplo:
{
"scripts": {
"install-all": "npm install --prefix backend && npm install --prefix frontend",
"build": "npm run build --prefix frontend",
"start": "npm run start --prefix backend"
}
}Execute os comandos:
- npm run install-all: Instala dependências do backend e frontend.
- npm run build: Gera a pasta dist do frontend.
- npm run start: Inicia o servidor backend.
Passo 7: Criar e Subir o Repositório no GitHub
Como preparar o projeto para o GitHub?
- Inicialize um repositório Git na pasta raiz:
git init - Adicione todos os arquivos:
git add . - Faça o commit inicial:
git commit -m "Configurações iniciais para deploy" - Renomeie a branch para main (se necessário):
git branch -M main - Vincule ao repositório remoto no GitHub:
git remote add origin <URL_DO_REPOSITORIO> - Envie o projeto:
git push -u origin main
Dica:
- Certifique-se de que o repositório é público (ou privado com acesso ao Render).
Passo 8: Configurar o Render para o Deploy
Como configurar o deploy no Render?
- Crie uma conta no Render (gratuita).
- Crie um novo "Web Service" e conecte ao repositório GitHub.
- Configure:
- Language: Node
- Branch: main
- Root Directory: (deixe em branco, pois o package.json está na raiz)
- Build Command: npm run build
- Start Command: npm run start
- Adicione variáveis de ambiente (ex.: chaves do MongoDB, AWS S3, etc.) no painel do Render.

Passo 9: Atualizar o Frontend com a Nova URL
Como ajustar a URL da API após o deploy?
Após o deploy, o Render fornece uma URL (ex.: https://seu-projeto.onrender.com). Atualize o baseURL no frontend:
const baseURL = import.meta.env.MODE === 'development'
? 'http://localhost:4000/api'
: 'https://seu-projeto.onrender.com/api';Faça um novo commit e push:
git add .
git commit -m "Atualização da base URL"
git pushPasso 10: Deploy Final e Testes
Como garantir que tudo funciona?
- No Render, clique em "Deploy latest commit" para atualizar o projeto.
- Acesse a URL fornecida pelo Render e teste:
- Verifique se o frontend carrega corretamente.
- Teste as chamadas à API (ex.: login, listagem de dados).
- Confirme a conexão com o banco de dados (MongoDB).
Tabela de Verificação:
| Funcionalidade | Teste | Status (verifique e marque ✅ ou ❌) |
|---|---|---|
| Frontend | Página inicial carrega corretamente | ✅/❌ |
| API | Chamadas (ex.: /api/users) funcionam | ✅/❌ |
| Banco de Dados | Conexão e leitura de dados | ✅/❌ |
| Autenticação | Login e persistência de sessão | ✅/❌ |
Conclusão
Com esses 10 passos, você consegue fazer o deploy de um projeto MERN de forma gratuita e eficiente.
O segredo é organizar bem o frontend e o backend, configurar as rotas corretamente e usar uma plataforma como o Render para simplificar o processo. Agora que seu projeto está online, teste todas as funcionalidades e compartilhe com o mundo!
Próximos passos:
- Adicione monitoramento de erros no Render.
- Considere otimizar o desempenho com lazy loading no React.
- Explore opções de escalabilidade (ex.: planos pagos ou outras plataformas).
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
O que você aprende neste vídeo
Resposta rápida: A aula leva o projeto MERN do minicurso do Hashbnb de localhost a uma URL pública em 10 passos: build do React, rotas com prefixo /api, package.json na raiz com scripts, repositório no GitHub e deploy no Render. A lógica serve para outros projetos e outras hospedagens.
Neste vídeo (24 min):
- 3:55 - Passo 1: rodar
npm run buildno front end para gerar a pastadist - 5:36 - Passo 2: servir a pasta
distde forma estática, montando o caminho compath.join - 6:30 - Rota com asterisco que devolve o
index.htmlpara qualquer caminho não mapeado - 7:16 - Passo 3: colocar o prefixo
/apinas rotas do back end e usar o mesmo prefixo no front - 8:57 - Passo 4: escolher a URL base conforme o modo, desenvolvimento ou produção
- 10:30 - Passo 5: criar um
package.jsonna raiz comnpm init -y - 11:58 - Passo 6: o script
start, que sobe o servidor do back end - 13:07 - O script
build, que instala as dependências dos dois lados e gera a pastadist - 15:05 - Passo 7: criar o repositório no GitHub e enviar o projeto
- 18:31 - Passo 8: criar um web service no Render, com os comandos de build e start e as variáveis de ambiente
- 20:58 - Passo 9: trocar a URL base pelo endereço que o Render gerou e enviar o commit
- 22:17 - Passo 10: novo deploy e teste da aplicação no ar
Trechos do vídeo:
- Quando o front end e o back end são publicados no mesmo lugar, vale separar as rotas do back end com o prefixo
/api; em domínios diferentes, as rotas podem ficar como cada um preferir. - O Render roda os scripts do
package.jsonda raiz do repositório, sem entrar nas pastas do back end e do front end, e por isso os scripts usam--prefixpara apontar para cada pasta. - O arquivo
.envnão vai para o GitHub: as variáveis de ambiente do projeto são enviadas pelo Render, cada projeto com as suas. - Na aula, o endereço gerado pelo Render só aparece depois do primeiro deploy; com um domínio já comprado e conhecido, dá para acertar a URL base já no primeiro deploy, sem os passos 9 e 10.
- Na aula, o plano gratuito do Render é o escolhido, e a aula observa que o serviço fica melhor no plano pago, em capacidade do servidor, tempo no ar e atualizações automáticas.
FAQ - Como fazer deploy gratuito
1. O que é necessário para fazer o deploy de um projeto MERN?
Para fazer o deploy de um projeto MERN, você precisa de um projeto com frontend (React) e backend (Node.js/Express) configurados, um banco de dados MongoDB (pode ser gratuito, como o MongoDB Atlas), uma conta no GitHub para hospedar o repositório e uma plataforma de deploy, como o Render. Além disso, certifique-se de ter o Node.js e o npm instalados localmente para rodar os comandos de build e instalação.
2. Posso usar outra plataforma além do Render para o deploy?
Sim! A lógica dos 10 passos pode ser adaptada para outras plataformas, como Heroku, Vercel ou Railway. As principais diferenças estarão nos comandos de build e start, além das configurações de variáveis de ambiente, que variam de acordo com a plataforma escolhida.
3. Por que preciso criar uma pasta dist no frontend?
A pasta dist é gerada pelo comando npm run build no React e contém os arquivos estáticos (HTML, CSS e JavaScript) otimizados para produção. Esses arquivos são necessários para que o servidor consiga servir o frontend de forma eficiente ao usuário final.
4. Como evitar conflitos entre rotas do frontend e do backend?
Para evitar conflitos, adicione um prefixo, como /api, a todas as rotas do backend (ex.: /api/users). Isso separa as rotas do backend das rotas do frontend gerenciadas pelo React Router. No frontend, atualize as chamadas à API para usar esse prefixo.
5. O que fazer se o deploy no Render falhar?
Se o deploy falhar, verifique os logs no painel do Render para identificar o erro. Problemas comuns incluem: variáveis de ambiente ausentes (ex.: conexão com o MongoDB), dependências não instaladas corretamente ou erros nos scripts de build/start no package.json. Certifique-se de que o repositório GitHub está acessível e que os comandos no Render estão corretos.
Hashtag Treinamentos
Para acessar publicações de Full Stack, clique aqui!
Posts mais recentes de Full Stack
- LESS CSS: Guia Completo do Pré-processador (2026)LESS CSS é um pré-processador que adiciona variáveis, mixins, nesting e operações matemáticas ao CSS. Aprenda a configurar e usar com projeto prático.
- Variáveis no CSS (CSS Variables): Como Usar de Forma ProfissionalVocê sabe o que são Variáveis no CSS (CSS Variables)? Aprenda como usar técnicas que vão transformar a forma como você escreve variáveis CSS.
- Try Catch no JavaScript: Programação Defensiva na PráticaAprenda a usar try catch no JavaScript e melhore a sua programação defensiva!
Posts mais recentes da Hashtag Treinamentos
- ChatGPT para criar fórmulas no Excel: 5 exemplos práticosAprenda a usar o ChatGPT para criar fórmulas no Excel com 5 exemplos práticos de SOMA, SOMASES, SE, PROCV e CONT.SES, e veja como pedir certo e validar.
- Cursor para iniciantes: tutorial completo passo a passoCursor para iniciantes: aprenda a instalar, configurar o modelo, usar os modos Plan e Ask e criar sua primeira automação em Python com IA.
- Claude Artifacts: crie dashboards, slides e sites com IAAprenda a usar o Claude Artifacts para criar dashboards, apresentações e sites com IA a partir de um prompt, com exemplos e prompts prontos para copiar.









