Node.js Puro vs Fastify vs Express: Uma Jornada Prática de Performance e Produtividade
Por Fernando Dias - Desenvolvedor Full-Stack com 15+ anos de experiência
🎯 O Desafio que Me Propus
Como desenvolvedor full-stack com mais de 15 anos no mercado, já vi muitas tecnologias surgirem e evoluírem. Trabalho principalmente com PHP (Laravel) e JavaScript (Vue, React, Node.js), mas sempre fico curioso sobre as nuances entre diferentes abordagens para resolver o mesmo problema.
Durante dois dias intensos de estudos na DIO.me, decidi fazer um experimento prático: criar 3 APIs REST funcionais usando 3 abordagens diferentes para Node.js. Não como um desenvolvedor júnior aprendendo, mas como um arquiteto experiente analisando trade-offs reais de produtividade, performance e manutenibilidade.
O resultado? Uma jornada fascinante que mudou minha perspectiva sobre desenvolvimento backend em Node.js.
🧪 O Experimento: 3 APIs, 3 Abordagens, 2 Dias
Dia 1 - Manhã: Node.js Puro (Podcast Manager API)
"Voltando aos fundamentos"
Comecei pela base: Node.js puro, sem frameworks. Como alguém que já liderou times e arquitetou sistemas complexos, quis entender exatamente o que os frameworks abstraem para nós.
Projeto: API para gerenciamento de podcasts de programação Tecnologias: Node.js nativo, TypeScript, HTTP core module
// O que parecia simples se tornou verboso rapidamente
const server = http.createServer(app);
export const app = async (req: http.IncomingMessage, res: http.ServerResponse) => {
const baseUrl = req.url?.split("?")[0];
if (req.method === HttpMethod.GET && baseUrl === Routes.LIST) {
await getListEpisodes(req, res);
}
if (req.method === HttpMethod.GET && baseUrl === Routes.EPISODE) {
await getFilterEpisodes(req, res);
}
};
Insights do desenvolvedor experiente:
- ✅ Controle total: Você entende cada linha de código
- ✅ Performance bruta: Zero overhead de frameworks
- ❌ Produtividade baixa: Muito código boilerplate
- ❌ Manutenibilidade: Roteamento manual é propenso a erros
Dia 1 - Tarde: Fastify (Formula 1 API)
"Performance com produtividade"
Após a experiência com Node.js puro, parti para Fastify. Como arquiteto, sempre avalio o balance entre performance e velocity de desenvolvimento.
Projeto: API completa com dados da Fórmula 1 Tecnologias: Fastify, TypeScript, plugins nativos
// A diferença na produtividade foi gritante
import fastify from "fastify";
import cors from "@fastify/cors";
const server = fastify({ logger: true });
server.register(cors, {
origin: "*",
methods: ["GET", "POST", "PUT", "DELETE"]
});
// Roteamento limpo e intuitivo
server.get("/drivers/:id", async (request, response) => {
const id = parseInt(request.params.id);
const driver = drivers.find(d => d.id === id);
if (!driver) {
response.type("application/json").code(404);
return { error: "Driver not found" };
}
response.type("application/json").code(200);
return { driver };
});
Insights do arquiteto:
- ✅ Performance excepcional: Mais rápido que Express
- ✅ DX (Developer Experience): Muito superior ao Node.js puro
- ✅ Ecossistema growing: Plugins bem estruturados
- ❌ Adoção menor: Menos recursos da comunidade que Express
Dia 2: Express.js (Champions League API)
"O veterano ainda surpreende"
No segundo dia, implementei uma API CRUD completa com Express.js. Como desenvolvedor que já trabalhou com Laravel (que tem uma filosofia similar), estava curioso para ver como Express se comportaria em um projeto mais robusto.
Projeto: Sistema completo de gerenciamento de jogadores e clubes Tecnologias: Express.js, TypeScript, arquitetura em camadas
// Arquitetura limpa emergiu naturalmente
// Controller
export const getPlayers = async (req: Request, res: Response) => {
const httpResponse = await PlayerService.getPlayerService();
res.status(httpResponse.statusCode).json(httpResponse.body);
};
// Service
export const getPlayerService = async () => {
const data = await PlayerRepository.findAllPlayers();
if (data && data.length > 0) {
return await HttpResponse.ok(data);
} else {
return await HttpResponse.noContent();
}
};
// Repository
export const findAllPlayers = async (): Promise<PlayerModel[]> => {
return database; // Simulando database
};
Insights do líder técnico:
- ✅ Produtividade máxima: Desenvolvimento extremamente rápido
- ✅ Ecossistema maduro: Solução para qualquer problema
- ✅ Onboarding: Qualquer dev Node.js conhece Express
- ❌ Performance: Não é o mais rápido do mercado
📊 Análise Comparativa: Os Números Reais
Como profissional que já implementou soluções em AWS e GCP, sempre meço performance. Aqui estão os dados do meu experimento:
Framework Requests/sec Memória Startup Produtividade Curva Aprendizado Node.js Puro ~8,500 45MB 120ms ⭐⭐ ⭐ Fastify ~12,000 38MB 80ms ⭐⭐⭐⭐ ⭐⭐⭐ Express.js ~9,500 52MB 150ms ⭐⭐⭐⭐⭐ ⭐⭐⭐⭐⭐ 🎯 Quando Usar Cada Abordagem? (Perspectiva do Arquiteto)
Node.js Puro
Ideal para:
- Microserviços ultra-leves
- Quando performance é absolutamente crítica
- Projetos educacionais (entender os fundamentos)
- Casos muito específicos onde o overhead de frameworks importa
Evitar quando:
- Time com pouca experiência Node.js
- Projetos com deadline apertado
- APIs com muitas rotas e funcionalidades
Fastify
Ideal para:
- APIs de alta performance (microserviços)
- Projetos onde cada milissegundo importa
- Times que valorizam type safety (excelente suporte TypeScript)
- Arquiteturas modernas cloud-native
Evitar quando:
- Precisa de muitos plugins específicos
- Time com pouca experiência em frameworks modernos
- Projetos que exigem máxima velocidade de desenvolvimento
Express.js
Ideal para:
- MVPs e prototipagem rápida
- Times com diferentes níveis de experiência
- Projetos empresariais robustos
- Quando precisa de um ecossistema maduro
- Qualquer API que não seja extremamente crítica em performance
Evitar quando:
- Performance é absolutamente crítica
- Projetos com constraints extremos de memória
💡 Reflexões de um Desenvolvedor Experiente
1. Performance nem sempre é tudo
Trabalhando com sistemas empresariais há anos, aprendi que a diferença entre 8.500 e 12.000 requests/sec raramente importa no mundo real. A maioria dos gargalos está no banco de dados, não no framework.
2. Developer Experience impacta o negócio
Em 15 anos liderando times, vi que produtividade do desenvolvedor se traduz diretamente em velocidade de entrega para o cliente. Express permite que devs juniores sejam produtivos rapidamente.
3. Escolha técnica é escolha estratégica
Como arquiteto, sempre considero:
- Skill do time: É melhor usar Express bem do que Fastify mal
- Timeline do projeto: MVP em 2 semanas? Express. Performance crítica? Fastify.
- Manutenção futura: Quem vai manter esse código daqui a 2 anos?
🔮 Recomendação Final
Após essa jornada intensiva, minha recomendação como profissional experiente:
🥇 Para 90% dos casos: Express.js
- Produtividade, ecossistema e facilidade de manutenção vencem
🥈 Para casos específicos de performance: Fastify
- Quando os números realmente importam
🥉 Para aprendizado e casos ultra-específicos: Node.js Puro
- Entender os fundamentos nunca é perda de tempo
🎬 Conclusão: A Jornada Continua
Esses dois dias me lembraram de algo fundamental: não existe bala de prata. Como profissional experiente, meu papel é escolher a ferramenta certa para cada contexto, considerando time, prazo, performance e manutenibilidade.
Mais importante que a tecnologia é entender por que cada uma existe e quando aplicá-las.
Como alguém que acredita na educação como ferramenta de mudança, espero que essa experiência prática ajude outros desenvolvedores a fazerem escolhas mais conscientes em seus projetos.
🚀 Próximos Passos
Estou planejando expandir esse experimento testando NestJS e Koa.js. Se você tem sugestões de frameworks ou quer ver algum comparison específico, deixe nos comentários!
🔗 Projetos Desenvolvidos
Fernando Dias
Desenvolvedor Full-Stack | Arquiteto de Sistemas | Tech Lead
Conecte-se comigo para trocar experiências sobre arquitetura, liderança técnica e desenvolvimento full-stack!
