Why We Open-Sourced MySigMail Card, an HTML Email Builder

Most visual email builders make the first step easy: create an account, choose a template, and start dragging blocks. The harder question comes later. What happens when you stop paying, need to move the template, want to run the editor on your own infrastructure, or need to make it part of another product?

We built MySigMail Card around a different answer. Card is a free, open-source visual email builder that works without registration, exports responsive HTML, and preserves the editable template as JSON. You can use the hosted editor, deploy the static application yourself, or work with the source code under its licence.

That portability is the reason we opened the project—not simply to publish another drag-and-drop editor.

Card grew out of a commercial product

Card began inside MySigMail, where we had already spent years working with the awkward realities of email HTML. A message is not a regular web page. CSS support varies between email clients, layout still relies heavily on tables, and critical styles often need to be inlined.

When Anton Reshetov began developing Card publicly in 2022, the goal was to turn that commercial experience into an independent tool: useful to a marketer who does not write code, but structured enough for a developer to inspect, host, and extend.

That origin shaped two decisions.

First, the editor produces markup for email clients rather than moving ordinary website layouts into an inbox. Second, the visual canvas is backed by a controlled document model instead of an opaque project format that only one hosted service can understand.

The Card workspace keeps the block library, email canvas, and element settings in one view.

The problem is not the cloud; it is having no exit

Cloud software is convenient. It can also make the editable version of a template inseparable from the platform that created it. Downloading the final HTML helps, but HTML alone is a poor source file for a visual editor. Importing arbitrary markup back into a structured canvas is unreliable because the editor no longer knows which parts were rows, cells, controls, or reusable components.

Card therefore gives the user two outputs with different jobs:

The JSON can be imported in replace mode to open a project or append mode to add imported content to the current one. Imports pass through schema validation and sanitization before they are applied. Card does not claim to reverse-engineer arbitrary HTML into editable blocks; the JSON is the portable source of truth.

This is a small distinction with a large practical effect: leaving the hosted editor does not require leaving the editable project behind.

What using Card looks like

A typical workflow is deliberately straightforward:

1. Choose a ready-made block from the library.
2. Drag it onto the canvas and arrange the structure.
3. Edit copy, images, buttons, links, colors, spacing, borders, and alignment.
4. Check the desktop and mobile views.
5. Export HTML for your email service provider.
6. Export JSON when you want to archive, transfer, or continue editing the source.

The current catalog contains 78 blocks across eight categories: Menu, Header, Content, Feature, Call to Action, E-Commerce, Transactional, and Footer. These are starting points, not locked templates. Rows contain cells; each cell can combine text, buttons, images, dividers, composed elements such as menus and social links, and nested rows.

The block catalog provides complete sections that can be combined and restyled rather than a single fixed template.

Text and button labels can be edited directly in the message. Rich-text formatting is powered by Tiptap, and Google Fonts include system fallback choices for environments where the web font is unavailable. The editor also includes undo and redo, recent and document colors, an EyeDropper where the browser supports it, and automatic browser storage through localStorage.

The preview has desktop and mobile modes, plus controls for mobile visibility and column behavior. These tools help catch layout problems, but they are not a substitute for sending test messages to the clients your audience actually uses.

Inline editing remains connected to the Block → Row → Cell → Atom structure shown in the tree.

A visual interface with a controlled structure

The central design choice in Card is the relationship between the canvas and the document model.

For a non-technical user, the experience is visual: drag, edit, preview, export. Underneath, the template follows a versioned Block → Row → Cell → Atom contract. The same ordered tree drives the editor preview, the JSON project, and the exported email.

This matters for developers because the output is predictable enough to validate and evolve. It matters for designers and marketers because the editor can offer freedom without allowing every browser layout technique to leak into the email. Card uses Vue 3 and TypeScript for the application, table-based markup for critical email layout, inline styles where they matter, and Shadow DOM to keep the editor interface from interfering with the message being designed.

The result is not “web design, but emailed.” It is a constrained email system presented through a visual interface.

Self-hosting is intentionally uneventful

Card is a client-side application. A standard deployment does not need a backend, database, account system, or server-side template storage. Build the project once and serve the generated static files with nginx, Caddy, Apache, or a static hosting service.

The basic path from the official self-hosting guide is:

git clone https://github.com/mysigmail/card.git
cd card
pnpm install
pnpm build

The build produces a dist/ directory. Templates stay in each user's browser unless the user exports them or a team deliberately adds its own storage layer.

There is currently no official prebuilt Docker image. The guide includes a Dockerfile for teams that prefer containers, but it builds Card from source and serves the static output with nginx.

For a small business or agency, this means the editor can live alongside existing internal tools without adding another recurring account. For an infrastructure-conscious company, it means the editor and its local project data can remain under the company's operational control. For a SaaS team, the source provides a foundation to evaluate or adapt, subject to the licence terms.

What Card does—and what it deliberately leaves to other tools

Card builds email templates. It is not an email marketing platform.

After export, sending remains the job of an ESP or another delivery service. Image hosting, analytics, direct platform integrations, AI features, and collaborative editing are not part of the current open-source editor. The project is in active development, and email-client testing remains essential for production messages—especially across different Outlook versions.

Open source, with a commercial path for proprietary products

The open-source edition of Card is distributed under AGPL-3.0. You can use it and self-host it for free. If you modify Card and make that version available to users over a network, the licence includes source-availability obligations. Teams that want to embed Card in a closed-source commercial product can request a separate commercial licence.

That paragraph is a product overview, not legal advice. Before embedding or redistributing the editor, review the licence and your intended deployment with someone qualified to interpret it for your organization.

Why we are building Card in public

Opening the source does not make maintenance free. It does make the project's tradeoffs visible.

Users can see that Card has no campaign engine pretending to be an editor feature. Developers can inspect the template contract instead of trusting an undocumented export. Teams can decide whether the hosted editor, a self-hosted deployment, or a licensed integration fits their constraints. And when the project is not ready to promise something—universal client compatibility, an official Docker image, or cloud collaboration—we can say so plainly.

As of August 26, 2026, the GitHub repository has more than 400 stars. The number is encouraging, but the more important signal is what people are asking for: a capable visual tool that does not require them to rent access to their own editable templates.

Card is our answer so far. It is free to try, open to inspect, and designed to let the work leave with the user.

Want to run it yourself? Read the self-hosting guide or explore the source code and releases on GitHub.