One source of truth for every email template
Build clean, bulletproof HTML email once. Version it, manage it, and push it to your ESP — and it never changes under you. Think of it as a CMS for your email templates.
For developers and operators who need email templates that render everywhere and stay predictable.
Email templates rot.
You build a template that renders perfectly everywhere. Then someone edits a shared block, an import quietly drops the Outlook fixes, or the API serves something different from what you tested — and you don’t find out until it’s in an inbox. Close is worse than broken: it looks fine right up until it doesn’t.
Maiilo fixes the part everyone else leaves as a black box: what your template actually is, everywhere it’s used, over time.
- Imports that lose the fragile bits.
- Most builders convert your HTML into their block model — and the bulletproof parts (Outlook ghost tables, VML, nested tables) die first. The import “succeeds,” but what made it render everywhere is gone.
- Output that changes under you.
- Edit a draft, tweak a shared block — and suddenly your live template serves something you never reviewed. No version, no record, no going back.
- A push you can’t see.
- Sending a template to your ESP is usually a ghost step — no log, no confirmation of what went where, no way to know when it’s out of sync.
Not just a builder. A source of truth.
Most email builders stop at export. Maiilo treats every template as a versioned, governed artifact — so what you publish is exactly what gets served, and you can always see what changed and roll it back.
Versioned publishing
Every time you publish, Maiilo freezes an exact, immutable version. Your API and your ESP serve that — byte for byte — until you deliberately publish again. No silent changes.
Version history & rollback
See every published version, who published it, and when. Restore any previous version into your draft, then publish it. Your template’s history is a record you can trust, not a mystery.
Predictable, byte-exact output
What you test is what ships. Edit a draft all you want — the live version doesn’t move until you publish. The unpredictability that breaks email is gone by design.
Blocks that sync on your terms
Save any section as a reusable block. Change it once, and Maiilo shows you exactly which templates are affected — then you re-publish them when you’re ready. Updates propagate deliberately, never silently mid-send.
Push to your ESP — and actually see it happen.
Connect your ESP and push your published template straight into it. Maiilo logs every push — what version went, when, and whether it succeeded — and tells you when your ESP is running an older version than what you’ve published, so you know exactly when to re-sync.
The API-transfer step that’s usually a black box becomes something you can watch.
- Connect once.
- Securely store your ESP credentials, encrypted.
- Push published versions.
- Send the exact frozen version — no surprises.
- Drift detection.
- Publish a change and Maiilo flags every template that’s now behind in your ESP.
- Full push history.
- Every attempt, logged and visible.
A builder that gets out of your way.
Drag and drop to build clean, cross-client HTML — no wrestling with tables or inline styles. Or drop into a Code Block and write raw HTML when you need full control. Either way, the output is bulletproof.
- Clean, cross-client HTML
- Renders correctly in Outlook, Gmail, Apple Mail, and mobile — the fragile stuff handled for you.
- Custom HTML when you need it Pro
- Write raw HTML anywhere in your template. Perfect for advanced layouts and custom components.
- Import your existing HTML Pro
- Bring in the templates you already trust — kept verbatim, not converted into a block model that breaks them.
- Dynamic variables
-
Add
{{variables}}in text, links, images, subjects, and preheaders. The API returns detected variables alongside your HTML.
How it works
From design to production, with a source of truth the whole way.
-
Build
Drag and drop, or write raw HTML. Clean, cross-client output.
-
Publish
Freeze an exact version. That’s what gets served, until you publish again.
-
Serve & push
Fetch via API or push to your ESP — the exact frozen version, every time. See every version, roll back anytime.
Pricing
Two plans. Start free, upgrade when you’re shipping to production.
Free
For freelancers, side projects, and getting started.
$0 / forever
- Drag-and-drop builder
- 10 templates, 5 reusable blocks
- Versioning & rollback
- Clean HTML export
- API access — up to 100 fetches/month
Pro
14-day free trialFor teams shipping to production.
$12 / month
- Everything in Free
- Unlimited templates & blocks
- Custom HTML Code Block
- Import existing HTML
- ESP push with drift tracking (SendGrid)
- API access — up to 10,000 fetches/month
- Priority support
Need more? Contact us for custom plans
Questions about email template management
Maiilo is a management platform for your email templates — think of it as a CMS for email. Build clean, cross-client HTML, version it, and serve or push the exact published version via API or to your ESP. What you publish is what ships, and you can roll back anytime.
Builders stop at export. Maiilo keeps your templates as versioned, governed artifacts: predictable published output, full version history and rollback, deliberate block sync, and tracked ESP push. It’s the layer that manages your templates over time, not just the tool that creates them.
Yes. Maiilo generates clean HTML with tables and inline styles that render correctly in Outlook, Gmail, Apple Mail, and mobile.
SendGrid today, with more coming. You connect your ESP, push your published version, and Maiilo tracks exactly what was pushed and when — flagging when your ESP is behind your latest published version.
Every publish freezes an exact, immutable copy. Your API and ESP serve that version byte-for-byte until you publish again — so nothing changes under you. You can view every version, restore any of them into your draft, and publish it again.
Yes, on all plans. The API serves your published template’s exact frozen HTML and its variables. Free includes up to 100 requests/month; Pro up to 10,000.
Save any section as a reusable block and drop it into any template. When you edit a block, Maiilo shows you every template that uses it and lets you re-publish them deliberately — updates never propagate silently mid-send.
Your email templates, under control.
Build clean, version everything, push anywhere — and never wonder what’s actually live.
Launch notes & changelog
Occasional email about what shipped. No campaigns.