Build email templates your whole team can use, with variables, previews and version history.
AI drafts subject lines and copy variants; your team approves what ships.
Work visually or in code, whichever fits the author.
Marketers can build visually while developers can work in HTML, and both produce the same template. Each author uses the tool that suits them, and nobody has to wait for a developer to change a sentence.
Personalise content and show blocks conditionally.
Personalise with variables for names, order details or anything else you pass in, and show or hide blocks with conditions. One template can serve many audiences instead of many near-copies.
Every change is saved and can be restored.
Every change is saved as a version you can compare and restore. If an update breaks a layout, you roll back in a click instead of rebuilding from memory.
Check rendering before anything goes live.
Preview a template and send a test to yourself before anything reaches customers. Catching a broken button or missing variable in testing is far cheaper than in production.
Share headers, footers and legal text.
Shared headers, footers and legal text live in one place. Update the block once and every template that uses it stays consistent, which matters for brand and compliance copy.
Keep brands and clients separate.
Libraries keep each brand or client's templates separate, so teams only see what belongs to them. It suits agencies and multi-brand companies that need tidy, safe organisation.
Start blank or from a base layout.
Mark the parts that change per message.
Call the template from the API or SMTP headers.
Each stage plays automatically. Select one to pause on it. Illustrative interface: all figures and addresses shown are sample data.
Marketing and support can edit content while engineering keeps the sending logic untouched.
An email template is a reusable layout with placeholders that your system fills with real data when it sends a message. The MigoSMTP template editor lets you build templates visually or in HTML, mark variables such as a first name or order number, add conditional blocks, and send by template name from the API or SMTP headers. Every change is saved as a version. Authors preview changes with sample data before anything is sent.
Templates are for teams where developers and non-developers share email. Marketing and support can edit wording and design, while engineering keeps the sending logic untouched. Role-based rights separate who can edit from who can publish, and previews with sample data let authors check rendering before anything goes live. Reusable blocks keep headers, footers and legal text consistent. Plain-text parts are generated automatically and can be edited by hand, and test sends confirm rendering before launch.
Template quality affects deliverability more than most teams expect. Broken HTML, missing plain-text parts and spammy phrasing all hurt inbox placement. A managed editor catches these before sending, and AI assistance can suggest subject lines and tighten copy, with a person approving every change before it is published. Teams that standardise on templates also find it easier to meet brand, accessibility and legal requirements, because the footer and unsubscribe wording live in one place.
Create an order-shipped template with order number, tracking link and an optional gift note. Your code sends the name and variables, and copy tweaks never need a deploy.
Let the marketing team update promotional wording and imagery in the editor, publish when approved, and leave engineering free of requests for small text changes.
Keep each client's brand blocks and templates in a separate workspace library, so headers, footers and legal text never leak between accounts.
If a published change breaks rendering, open the version list and restore the previous version. Messages sent afterwards use the restored template immediately.
Keep password resets, sign-in alerts and verification messages in templates with fixed wording and your legal footer, so the same approved text is used every time.
Maintain one template per language with the same variables, and let your code pick the version by customer locale. Reviewers can read each language side by side.
Both work. The difference is who can change an email and how fast.
Your code only sends the template name and the variables, so the sending logic stays the same either way.
Give the assistant a goal and audience and it proposes several subject lines and preheaders. You choose, edit or discard; nothing is saved to a live template without your approval.
Highlight a paragraph and ask for shorter, clearer or more formal wording. The assistant shows its edit as a suggestion that you accept or reject, preserving your variables.
A copilot checks a template for broken variables, missing alt text, heavy images and phrases that commonly trigger spam filters, then lists fixes. You decide which to apply.
For campaign-style sends, models suggest delivery windows based on past engagement of your own audience. Suggestions are optional, and you can keep a fixed schedule.
AI features are assistive: they propose wording and checks, and your team reviews and publishes every template.
Multipart messages with a sensible text version look more legitimate to filters and work better for accessibility. Generate it from HTML, then edit by hand.
If a first name is missing, an empty greeting looks broken. Define a fallback such as a neutral salutation for every personalised field.
Test with long names, missing values and unusual characters. Edge cases are where layouts and conditions most often fail.
Edit in draft, send a test to yourself, and publish only after review. Role-based rights make this a rule rather than a habit.
Avoid image-only emails and oversized files. Check rendering in the clients your audience uses, since support for CSS differs widely.
Use names like order-shipped or password-reset. Code that sends by name stays readable, and authors can find the right template quickly.
Moving existing emails into templates? Our team can help you plan it.
An email template is a saved email layout with placeholders, called variables, that are replaced with real values when a message is sent. It lets you write the design and wording once, then send many personalised messages from code or a campaign.
Create the template, mark its variables, then call it by name from the API with values for each variable, or reference it in SMTP headers. The system renders the template and delivers the message. See the API reference for fields.
The editor supports variables and conditional blocks, and the preview shows the rendered result with sample data before you publish. The documentation lists the exact syntax. Describe each variable in the template notes so authors know what to fill in.
Yes. Paste or upload your HTML and add variables where content should change. Review the preview, check the plain-text version, and send a test before using the template in production.
A template is reusable content and layout. A campaign or send is an instance of that content going to specific recipients at a point in time. One template can power many sends, so improving it improves all of them. Review the result carefully before publishing.
Yes. Every saved change creates a version, and you can restore an earlier one. Messages sent after the restore use the restored version, while earlier messages are unaffected. Rollback is useful when a late edit breaks a layout. Compare versions side by side first to be sure you restore the one you want to keep.
AI can suggest subject lines, tighten copy and review a template for broken variables and spam-trigger phrases. Every suggestion is optional, and your team reviews and publishes each template.
Yes. Role-based rights let marketers and support staff edit and, if you allow it, publish content, while developers retain control of API keys and sending logic. Draft and published versions keep unfinished work away from live sends. Drafts stay private until they are published.
The DPDP Rules were published in November 2025 and phase in over 18 months. We explain the notice, consent, security, breach and retention duties in plain terms, the reported penalty ceilings and a plan for email programmes.
Password-based SMTP in Exchange Online is being retired after two postponements. We set out the reported timeline, what fails and when, the five migration routes and why system mail belongs on its own sending path.
As passkeys replace passwords, sign-in mail should shrink while recovery and security alerts matter more. We review the 2026 FIDO data and work through each message type and three scenarios to 2030.
Apple accounts for 62.26% of tracked opens, and AI assistants now read mail for people. We look at why the open rate fails, what the data says and which signals to measure instead.
Fluent, targeted phishing is now cheap. We review the figures and their weaknesses, explain what authentication can and cannot stop and set out what legitimate senders should do next.
BIMI shows a verified logo beside authenticated email, but its entry ticket is enforced DMARC. We set out Gmail's requirements, VMC against CMC, the unverified vendor claims and three scenarios to 2028.
A new class of sender is arriving: software agents with their own inboxes. We review the 2026 funding and product signals, the deliverability and security risks and three scenarios to 2030.
Two independent 2026 studies show DMARC records are common while enforcement lags. We compare their numbers, explain why domains stall at p=none and set out a 90-day plan to move to reject.
Create an account, add your domain and send your first email.
