Engenharia/Front-end

Por dentro deste blog: Nuxt 4, Nuxt Content e markdown, tudo estático

Como este site foi construído: coleções tipadas, segmentos e categorias, capas geradas por código, RSS, sitemap e pré-renderização completa. Um guia prático para fazer o seu.

Murilo Anzini 3 min de leitura

Um blog técnico tem requisitos simples e exigentes ao mesmo tempo: precisa ser rápido, indexável, fácil de escrever e barato de hospedar. Depois de testar CMS headless, banco de dados e plataformas prontas, voltei para o formato mais antigo e mais robusto que existe: arquivos markdown num repositório, transformados em HTML estático no build.

Este post mostra como o site que você está lendo foi montado.

A stack

  • Nuxt 4: o framework, com renderização no servidor e geração estática;
  • Nuxt UI 4: componentes e o sistema de tema (cores, tipografia, modo escuro);
  • Nuxt Content 3: transforma a pasta content/ num banco consultável, com tipos;
  • Tailwind CSS 4: estilo utilitário, com os tokens da marca definidos em CSS.

Tudo sai pré-renderizado. Não existe servidor em produção: são arquivos HTML numa CDN.

nuxt.config.ts
export default defineNuxtConfig({
  modules: ['@nuxt/ui', '@nuxt/content'],
  // Tudo estático: rápido, barato e indexável
  routeRules: { '/**': { prerender: true } }
})
A ordem dos módulos importa: o Nuxt UI vem antes do Content, para que os componentes de tipografia dele (títulos, tabelas, blocos de código, avisos) renderizem o markdown.

Coleções tipadas

O Nuxt Content 3 trabalha com coleções: você declara de onde vêm os arquivos e qual o formato do frontmatter. Errou um campo? O build avisa.

content.config.ts
export default defineContentConfig({
  collections: {
    blog: defineCollection({
      type: 'page',
      source: 'blog/*.md',
      schema: z.object({
        date: z.string(),
        segment: z.enum(['engenharia', 'produto', 'dados', 'marketing', 'negocios']),
        category: z.string(),
        tags: z.array(z.string()).default([]),
        featured: z.boolean().default(false),
        draft: z.boolean().default(false)
      })
    })
  }
})

Consultar é parecido com escrever SQL, só que tipado:

const posts = await queryCollection('blog')
  .where('draft', '=', false)
  .where('segment', '=', 'engenharia')
  .order('date', 'DESC')
  .select('title', 'description', 'path', 'date')
  .all()

O select importa: nas listas, só os campos do cartão vão para o payload da página, sem o corpo dos artigos.

Segmentos e categorias

O blog tem dois níveis de organização. Segmentos são os grandes temas (Engenharia, Produto, Dados, Marketing, Negócios), cada um com cor, ícone e página própria. Categorias vivem dentro de um segmento (Arquitetura e Front-end em Engenharia, Discovery em Produto, e assim por diante).

A definição fica num único arquivo TypeScript, que alimenta o menu, os filtros, as cores e um script que confere se todo post usa um segmento e uma categoria que existem. Uma fonte de verdade, nenhuma lista duplicada.

Tempo de leitura calculado no build

Em vez de pedir para o autor preencher, o tempo de leitura é calculado num hook do Content, a partir do markdown cru, ignorando blocos de código:

nuxt.config.ts
hooks: {
  'content:file:afterParse'({ file, content }) {
    if (!file.id.startsWith('blog/')) return
    const text = String(file.body).replace(/```[\s\S]*?```/g, '')
    const words = text.split(/\s+/).filter(Boolean).length
    content.readingTime = Math.max(1, Math.round(words / 220))
  }
}

Assim o valor entra no banco e as listas mostram sem carregar o texto.

Capas geradas por código

Produzir uma imagem por post é o tipo de tarefa que faz um blog parar. Aqui, cada capa é um SVG desenhado por um componente Vue: um desenho por segmento (linhas de código, anéis, barras, ondas, uma rede), na cor do segmento, com variações tiradas do título por um gerador determinístico. Mesmo título, mesma capa, no servidor e no navegador.

O resultado: zero imagens para produzir, zero bytes de JPG, e todo post com a identidade visual do site.

Busca e filtros sem servidor

A página do blog sai pré-renderizada com todos os posts. Os filtros (segmento, categoria, busca) rodam no navegador, ignorando acentos e caixa, e vão para a URL para dar para compartilhar um filtro. Para algumas dezenas ou centenas de posts, é instantâneo e não precisa de nenhum serviço de busca.

SEO de verdade

Estático não significa esquecido pelos buscadores, pelo contrário. Cada página tem:

  • title, description e Open Graph próprios;
  • canonical apontando para a URL limpa;
  • JSON-LD de Person no site e BlogPosting em cada artigo;
  • sitemap.xml e rss.xml gerados por rotas do servidor e pré-renderizados no build.

Escrever um post

No fim, escrever é criar um arquivo:

content/blog/meu-post.md
---
title: 'Título do post'
description: 'Uma frase que convence a ler.'
date: '2026-11-12'
segment: engenharia
category: frontend
tags: [nuxt, vue]
---

O texto em markdown, com **negrito**, listas, tabelas e blocos de código.

Commit, push, e o deploy gera o HTML. Sem painel, sem banco, sem plugin para atualizar.

Conclusão

Para um blog pessoal ou de empresa, markdown versionado e geração estática continuam imbatíveis em custo, velocidade e durabilidade. O Nuxt Content 3 adiciona o que faltava: tipos, consultas e uma integração com a interface que faz o resultado parecer um produto, não um template.

#nuxt#nuxt-content#vue#frontend#seo

Murilo Anzini

Engenheiro de software com cabeça de produto, olho de dados e repertório de marketing. Analiso, crio e evoluo a jornada completa de um produto e da empresa por trás dele.

Sobre mim

Ebook gratuito

Criando infoprodutos de valor

A metodologia que uso para unir produto, marketing e vendas na criação de infoprodutos: do jeito que startups validam hipóteses, entendem necessidades e constroem o que o mercado quer comprar.

  • Entender o cliente e definir as hipóteses iniciais
  • Construir e testar um MVP enxuto
  • Medir o progresso e validar com dados
  • Saber a hora e o jeito de pivotar
Baixar grátis PDF · 23 páginas · sem cadastro