Back to Blog

How We Use Sutram to Power Our Own Website

By Sergio Vieira Greve
How We Use Sutram to Power Our Own Website

Dogfooding at its best: Sutram serves its own blog and documentation across six languages

The premise

There's a saying in software: if you wouldn't use your own product, why should anyone else? At Sutram, we took this to heart. Our marketing site — the one you're reading right now — is powered entirely by Sutram's own content infrastructure.

Every blog post, every documentation page, every piece of content you see here is stored, organized, and served from a Sutram project. This isn't a demo. It's production.

The architecture

The site is built with Astro, a modern static site generator. At build time, Astro calls the Sutram REST API to fetch all content, renders it into static HTML, and deploys to Netlify. No runtime dependencies, no database queries on page load — just fast, pre-built pages.

The content flow looks like this:

Sutram Project
  └── /{lang}/Blog/{year}/{post-slug}/
  │     ├── post.md          (markdown body)
  │     └── cover.jpg         (cover image, optional)
  └── /{lang}/Docs/{category}/{doc-slug}/
        └── guide.md          (markdown body)

        ↓  Sutram REST API  ↓

Astro (build time)
  → fetch folders + tags
  → download markdown files
  → convert cover images to WebP
  → render to static HTML

        ↓  deploy  ↓

Netlify (CDN)

Six languages, one structure

The site supports six languages: English, Portuguese, Spanish, French, German, and Italian. Instead of maintaining separate content systems or duplicating folder hierarchies, we use a simple convention: the language is the root.

/en/Blog/2026/how-we-use-sutram/
/pt/Blog/2026/como-usamos-o-sutram/
/es/Blog/2026/como-usamos-sutram/

Each language has its own Blog and Docs folder in Sutram. The API client maps language codes to folder IDs and fetches content accordingly — no tag filtering, no complex routing logic. The folder path is the language.

The site's UI strings (navigation, buttons, labels) are handled separately via JSON translation files, but all substantive content — the posts and docs you actually read — lives in Sutram.

Metadata as tags

Every content folder in Sutram carries metadata as tags — simple key-value pairs attached to the folder itself:

Tag Purpose
title Display title of the post or doc
author Post author name
excerpt Short description for listings and SEO
category Content category (e.g., "Engineering", "Product")
published_at Publication date (controls visibility and sorting)

This is one of Sutram's core features: structured metadata on any folder, without rigid schemas. The API client reads these tags to build listing pages, category filters, and RSS feeds — all at build time.

Cover images with automatic optimization

Blog posts can include a cover image as a file inside the post folder. During build, the Astro client:

  1. Detects the first image file in the folder
  2. Downloads it via the Sutram API
  3. Converts it to WebP format using sharp
  4. Resizes to 1200x630 (optimized for social sharing)
  5. Saves it to the static output directory

This means authors just drop an image into the Sutram folder — no manual resizing, no format conversion, no CDN configuration.

Managing content with AI and MCP

Here's where it gets interesting. We don't use a traditional CMS interface to write and publish content. Instead, we use Claude Code with the Sutram MCP Server.

The workflow:

  1. Write or translate a post in markdown (often with Claude Code's help)
  2. Create the destination folder in Sutram via sutram_create_folder
  3. Set the metadata tags via sutram_set_folder_tags
  4. Upload the markdown file via sutram_request_upload + sutram_confirm_upload
  5. Trigger a Netlify build

All of this happens from the terminal, in a single conversation session. No browser, no form fields, no copy-paste. The AI agent reads the content, creates the folder structure, sets the tags, uploads the file, and the site rebuilds automatically.

This very post was written, translated to Portuguese, and published to Sutram using exactly this workflow.

The API client

The heart of the integration is a single TypeScript file (sutram.ts) that acts as the bridge between Sutram and Astro. It handles:

  • Content discovery — recursively walks Sutram folders to find content records (any folder with a title tag)
  • Markdown fetching — downloads the first .md file from each content folder
  • Image processing — converts cover images to optimized WebP
  • Mock data fallback — returns placeholder content when API credentials aren't configured (for local development)

The client is about 460 lines of TypeScript. No framework, no ORM, no abstraction layers — just fetch calls to the Sutram API and sharp for image processing.

Why this matters

Dogfooding isn't just about credibility. It forces us to experience the same friction our users face. Every rough edge in the API, every missing feature, every confusing behavior — we feel it first.

Some things we discovered and improved by using Sutram for our own site:

  • Tag-based content detection works better than rigid folder naming conventions
  • Recursive folder traversal is essential for flexible content hierarchies
  • The MCP Server makes content management from the terminal not just possible, but preferable for technical teams
  • Per-language folder roots are simpler than tag-based language filtering

The numbers

Metric Value
Languages supported 6 (en, pt, es, fr, de, it)
Content types 2 (Blog posts, Documentation)
API calls per build ~20-30
Build time < 30 seconds
Runtime JavaScript 0 (static HTML)
CMS interface used None (MCP + terminal)

Conclusion

Using Sutram to power our own site is the strongest statement we can make about the platform. It's not a toy project or a proof of concept — it's the production system that serves every page you see here.

If your content needs structure, your team needs control, and your workflow benefits from automation — Sutram was built for exactly that. And we prove it every day, starting with this very page.

Back to Blog