
The lists, the people and the messages in this picture, and in the ones below, are made up.
parsimony is a mailing list manager that I wrote in Go. The README calls it “an evolution of Mailman”, and that is the idea: discussion lists and newsletters, moderation, bounces, an archive with search, and all of it in one program with one configuration file.
The first commit is from 9 November 2026 and I tagged version 0.1.0 the day after. It is free software under the GPL-3.0-or-later, and the code is at git.kmalloc.org/squid/parsimony.
This post is about why I think a mailing list manager fits well in a single static binary, what parsimony does today, how it is put together, and what is still missing.
Why one binary
Mailman 3 is a suite. There is the core that handles the mail, Postorius for the administration and HyperKitty for the archive. The last two are Django applications, so around them you also run a web server for Python, a database and the jobs that keep everything in sync.
If you look at what a list manager really does, the job is small:
- receive a message;
- decide if the sender may post;
- change a few headers;
- send one copy to every member;
- remember who bounced;
- keep the message so people can find it later.
None of these steps needs its own service. The state is small too: lists, members, a queue and an archive. So in parsimony everything lives in one process: the LMTP server that receives mail, the worker that sends it, the REST API, the admin UI, the public archive pages and the command-line client. The state is one SQLite file (in WAL mode), and the configuration is one YAML file.
I wrote down the scope before starting: tens of lists, thousands of subscribers each. For that size SQLite is enough. Postgres stays out until the scale asks for it.
Some numbers, measured on my machine for this post. A static build (CGO_ENABLED=0 go build, Go 1.27.3, linux/amd64) with the admin UI embedded is 24.5 MB, or 16.9 MB with -ldflags='-s -w'. Started with an empty database and no traffic, the daemon uses about 21 MB of resident memory (VmRSS in /proc, a few seconds after the start). The container image is built on distroless, runs as an unprivileged user and works with a read-only root filesystem: the only writable path is the volume with the database.
It is not a mail server
The first decision was what to leave out: parsimony is not an MTA. Postfix receives the mail from the world and hands the list domains to parsimony over LMTP. For sending, parsimony talks SMTP to a relay: Postfix again, or an external one such as Amazon SES or a smarthost, with TLS and authentication.
Receiving and delivering mail on the open internet is a job of its own, and Postfix already does it. parsimony speaks LMTP on one side and SMTP on the other, and nothing else.
What it does today
- Discussion lists. Only members post, the
List-*headers are added, andFromis rewritten to the list address (“Name via List title”) with the author inReply-To, so DMARC still passes. - DKIM. Outgoing mail is signed with one key per list domain (RSA or Ed25519).
parsimony dkim keygencreates the key and prints the DNS record to publish. - Subscribe by email, with double opt-in. Write to
list+join@domainorlist+leave@domain, then reply to the confirmation. A request expires after 72 hours. - Moderation. On a moderated list, posts wait until someone approves or discards them. A post whose
Fromheader does not match the real SMTP sender is held as well, on any list. - Bounces with VERP. Every recipient gets a signed return address. Three hard bounces within 30 days disable a member.
- Newsletters. A newsletter is a list where only members flagged as publishers can post. It has a public signup form, a rate limit for relays that throttle, and counters for each post: sent, failed, dropped, pending.
- Archive. Full-text search with SQLite FTS5, threading, and per list a policy: private, public or off. The public pages hide the email addresses.
- One-click unsubscribe (RFC 8058), with a signed link for each recipient.

The moderation queue. The second message says it is from Carol, but Bob sent it.
To manage all this there are three ways, and they are the same thing underneath. The REST API under /api/v1 is described in an OpenAPI file. The admin UI is a small React application that is compiled and embedded in the binary. The command-line client is the same binary again and talks to that API, so it works against a local or a remote daemon:
parsimony list add dev@example.org --title "Developers"
parsimony member add dev@example.org alice@example.com --name Alice
parsimony held ls dev@example.org
parsimony queue ls
The queue
The rule of the queue is short: a post is accepted only when it is stored.
When Postfix delivers a message, parsimony checks it, rewrites the headers and writes it to the outbox in one transaction: the body once, plus one row for each recipient. Only then LMTP answers 250. If the relay is down, Postfix does not notice and nothing bounces back to the author.
A background worker takes the rows that are due and sends them, four at a time by default. A temporary error is retried after 1 minute, then 5, 15, 1 hour, 3 hours, and then every 6 hours for up to 3 days. A permanent refusal is not retried, but it does not vanish either: it stays in the queue as failed, with the reason, for a week. DKIM signing happens at send time, on the final message, so the per-recipient unsubscribe headers are covered by the signature.
On stop, the daemon refuses new connections and lets the sessions in flight finish, so a post that is being received still gets its 250.
What remains is at-least-once delivery. If the process dies between the relay accepting a message and the row being removed, one recipient can get that message twice. The design takes a possible duplicate over a lost message.
How the code is laid out
The Go code is about 7,600 lines without the tests, and about 15,200 lines of tests. Each package under internal/ has one job:
ingestis the LMTP server;routerdecides what a message is (a post, a command, a bounce) and rewrites the headers;storeis SQLite: the schema and every query;queueis the worker with the retries and the pacer for the rate limit;outboundis the SMTP client, with a separate time limit for each step;dkimsign,archiveandmboxdo what their names say;api,web,adminuiandcliare the four faces.
There are six direct dependencies: go-smtp, go-message, go-msgauth and go-sasl from emersion for the mail protocols, yaml.v3 for the config, and modernc.org/sqlite, a SQLite that needs no cgo. That last one is what makes the build static.
Besides the unit tests there is an end-to-end test, make e2e. It starts a real Postfix and parsimony in Docker and walks the whole path: a post goes in, the copies reach the maildirs, a real 550 5.1.1 from Postfix disables a member after three bounces. Join and leave by email, moderation, the public archive and one-click unsubscribe are checked on the same path.
make scale measures a list of 10,001 members and an archive of 50,000 messages, and the README has the results from one machine: queueing a post for that list takes 0.12 seconds, and a search in that archive answers in 6 to 15 milliseconds. Sending is bound by the SMTP round trips to the relay, not by parsimony.
Coming from Mailman
Both Mailman 2 and Mailman 3 can export the history of a list as an mbox file, and parsimony imports it:
parsimony list add dev@example.org --title "Developers"
parsimony member import dev@example.org subscribers.txt
parsimony archive import dev@example.org dev.mbox
The import can be repeated: a message that is already in the archive (same Message-ID) is skipped. Threads are rebuilt from In-Reply-To, whatever the order of the messages in the file.

The archive of a list, with the search and the mbox import.

A public archive page. Names are shown, addresses are not.
What is missing
It is version 0.1.0, and the list of what it does not do is long:
- No digests. Every member gets every message, one by one.
- No subject prefix and no footer. The message body is passed on byte for byte.
- No check of incoming mail. parsimony does not verify SPF, DKIM or DMARC on what it receives. Postfix has to reject forged senders before the mail arrives.
- One admin token. There are no users, no roles and no list owners: who has the token can do everything. The API and the UI have no TLS of their own and need a reverse proxy in front.
- Moderators do not see the body. The held queue shows the subject, the sender and the size of a message, but not its text.
- The archive is plain text. Attachments are not kept, and HTML mail is stored as text.
- No page for members. A member joins and leaves by email or from the signup form. There is no page where a member manages a subscription.
- English only. The confirmation mails and the public pages are not translated.
- No scheduled sends, and no tracking of opens or clicks.
- SQLite only.
The README also lists a few known gaps in the corner cases, for example a held message that is held twice when the sender retries after a lost answer.
If you run Mailman and some of this sounds useful, the code is on git.kmalloc.org. Criticism is welcome, and so is the message that tells me which missing piece would stop you from trying it.