Today's Deep-Dive: dovel

[SPEAKER_01] Right now, the server processing your email is likely a massive bloated piece of software.

[SPEAKER_01] I mean, it probably requires gigabytes of memory, a dedicated IT team, and a server rack that sounds like a jet engine.

[SPEAKER_00] Yeah, that's pretty much the industry standard at this point.

[SPEAKER_01] But today, we are looking at a piece of software that runs that exact same global communication protocol on less memory than it takes to load a single high resolution photo on your phone.

[SPEAKER_00] which is just wild to think about.

[SPEAKER_01] It really is.

[SPEAKER_01] So welcome to the Deep Dive.

[SPEAKER_01] Our mission today is to explore a radically simple, highly unconventional way to take back control of your digital communications.

[SPEAKER_01] We're looking at a fascinating open source project called Double Email.

[SPEAKER_00] And it completely upends our standard assumptions about what it actually takes to build and maintain communication infrastructure.

[SPEAKER_00] We are just so used to throwing massive compute power at problems.

[SPEAKER_00] We've totally forgotten how lightweight the internet was actually designed to be in the first place.

[SPEAKER_01] Which makes you wonder why we tolerate the bloat at all, you know, especially when you consider the cost and control issues.

[SPEAKER_01] We are essentially just renting space on someone else's behemoth servers.

[SPEAKER_00] Exactly.

[SPEAKER_00] And this whole conversation about taking back control of our data is exactly why organizations are actively turning to open source alternatives.

[SPEAKER_01] Yeah, and that's actually why we partnered with Safe Server for today's deep dive.

[SPEAKER_01] When you look at the default choices today, you are usually looking at really expensive proprietary tools.

[SPEAKER_00] Oh, absolutely.

[SPEAKER_00] The giants like Microsoft 365 or Google Workspace.

[SPEAKER_01] Right.

[SPEAKER_01] You pay a massive premium and your data just lives in their black box.

[SPEAKER_00] The contrast is honestly stark when you evaluate the actual cost difference of switching to open source.

[SPEAKER_00] But it's not even just the financial aspect.

[SPEAKER_00] Think about the regulatory side of things.

[SPEAKER_01] Oh, right, like compliance.

[SPEAKER_00] Yeah.

[SPEAKER_00] If you're an organization dealing with email retention policies or strict data protection laws, financial records, critical audit trails, data sovereignty is absolutely paramount.

[SPEAKER_01] You really cannot afford to guess where your data lives.

[SPEAKER_01] Or who holds the ultimate decryption keys, for that matter.

[SPEAKER_00] No, you can't.

[SPEAKER_00] And that is precisely the gap that SafeServer fills.

[SPEAKER_00] They help organizations find and implement the right open-source solutions to replace those expensive proprietary monoliths.

[SPEAKER_01] And they handle the entire lifecycle, right?

[SPEAKER_01] From the initial consulting to figure out your exact needs, all the way to operating the software on secure servers located strictly within the EU.

[SPEAKER_00] Yeah, full service.

[SPEAKER_01] So if you want to regain total control of your infrastructure and ensure your data sovereignty, you definitely need to check them out at safeserver.de.

[SPEAKER_00] Because having those infrastructure options is critical.

[SPEAKER_00] And the source material we're looking at today provides a very unique, almost rebellious option for handling email.

[SPEAKER_01] Rebellious is honestly the perfect word for it.

[SPEAKER_01] We've got a stack of READDAM files, Git repositories, and website excerpts detailing Double.

[SPEAKER_00] And the premise here is just extreme minimalism.

[SPEAKER_00] Extreme is right.

[SPEAKER_01] The source is defined Double as an SMTP server that's designed to send and receive emails according to one simple JSON configuration file.

[SPEAKER_00] And to really appreciate how rebellious that is, we kind of need to understand the fundamental protocol first, SMTP, or a simple mail transfer protocol.

[SPEAKER_01] An absolute backbone of email for decades.

[SPEAKER_00] Right.

[SPEAKER_00] Fundamentally, SMTP is just a set of rules for passing text from one computer to another over the internet.

[SPEAKER_00] That is literally it.

[SPEAKER_01] OK, let's unpack this because reading through these specs, the footprint almost looks like a typo to me.

[SPEAKER_00] It really does.

[SPEAKER_01] It claims to use only a quote, few megabytes of RAM.

[SPEAKER_01] To put this in perspective for you, modern enterprise email servers feel like massive automated Amazon fulfillment centers.

[SPEAKER_00] Oh, yeah.

[SPEAKER_00] Miles of conveyor belts.

[SPEAKER_01] Exactly.

[SPEAKER_01] Robotic arms, sorting packages, huge databases tracking every item, heavy anti-spam heuristic engines checking every single box.

[SPEAKER_01] But Dovel is pitching itself as a single local mailman walking his route with a leather satchel.

[SPEAKER_00] That's a great way to put it.

[SPEAKER_01] But I have to push back here.

[SPEAKER_01] Can that local mailman actually survive the chaotic, spam-filled waters of modern email without all that automated machinery?

[SPEAKER_00] Well, what's fascinating here is that the reason modern servers feel like those massive fulfillment centers isn't because the core job of sending a message is hard.

[SPEAKER_01] Okay, then why is it?

[SPEAKER_00] It's because we've bolted on decades of extra features.

[SPEAKER_00] complex graphical web interfaces, integrated calendars, massive relational databases to index every single word of every email.

[SPEAKER_01] Ah, and incredibly heavy runtime environments to support all that.

[SPEAKER_00] Precisely.

[SPEAKER_00] Dovel survives the chaos by simply refusing to build the fulfillment center in the first place.

[SPEAKER_00] It's written in a programming language called Go, which is a compiled language.

[SPEAKER_01] meaning it translates directly into the computer's native machine code rather than needing some heavy translator program running in the background all the time.

[SPEAKER_00] Exactly.

[SPEAKER_00] That makes it blisteringly fast and incredibly memory efficient.

[SPEAKER_00] Plus, the sources highlight that it operates under the BSD3 clause license.

[SPEAKER_01] Which is a very permissive open source license, right?

[SPEAKER_00] Very permissive.

[SPEAKER_00] It essentially means anyone can take this code, use it, modify it, or distribute it with very few restrictions as long as they keep the original copyright notice.

[SPEAKER_01] Nice.

[SPEAKER_01] And instead of using a complex relational database to store its settings, it just uses JSON.

[SPEAKER_00] Right.

[SPEAKER_01] For those who aren't software developers, JSON is basically just a plain text file structured in a highly readable way, kind of like a digital notepad with simple lists and labels.

[SPEAKER_00] Yeah, it's entirely human readable.

[SPEAKER_00] You don't need a special database query language to read it.

[SPEAKER_00] You just open it in a basic text editor.

[SPEAKER_01] So Devil focuses purely on the essential SMTP transactions.

[SPEAKER_01] It loads incredibly fast.

[SPEAKER_01] But I did notice it doesn't sacrifice modern security standards to achieve that minimalist footprint.

[SPEAKER_00] No, not at all.

[SPEAKER_00] So even though it's the solitary mailman, it's definitely not a toy.

[SPEAKER_01] Yeah, the sources note it supports PGP encryption using the WKD standard right out of the box.

[SPEAKER_01] What is WKD again?

[SPEAKER_00] WKD stands for Web Key Directory.

[SPEAKER_00] It's a modern standard that allows email clients to automatically discover the public encryption keys of the person you are emailing.

[SPEAKER_01] Oh, wow.

[SPEAKER_01] So you don't have to do that manually.

[SPEAKER_00] Right.

[SPEAKER_00] By supporting this natively, Dovel allows users to send end-to-end encrypted messages seamlessly without manually trading complex cryptographic keys beforehand.

[SPEAKER_01] All right, I understand the philosophy, but how do you actually pilot this thing?

[SPEAKER_01] The sources outline what they call five easy steps to self-host.

[SPEAKER_00] Yeah, they make it sound very simple.

[SPEAKER_01] And looking at the installation, it genuinely seems frictionless.

[SPEAKER_01] You have two routes.

[SPEAKER_01] If you have that Go programming language installed, you just run a single command.

[SPEAKER_01] Go install double dot email server at v0.13.1.

[SPEAKER_01] Yep, that's one way.

[SPEAKER_01] Or, if you prefer using isolated software containers, they have a Docker image.

[SPEAKER_01] You literally just type, docker run bleemidevel, point it to your configuration folder, and the software is running.

[SPEAKER_00] And is remarkably fast to get running locally.

[SPEAKER_01] I'm looking at these instructions, and honestly, I'm a bit skeptical.

[SPEAKER_01] Surely pulling down a single binary file doesn't instantly make you a verified sender to Google or Microsoft, right?

[SPEAKER_01] No.

[SPEAKER_00] Your skepticism is entirely warranted there.

[SPEAKER_00] The software installation is easy, but setting up the server software is really only half the battle of self-hosting email.

[SPEAKER_01] That's what I figured.

[SPEAKER_00] Getting the software running on your machine is one thing.

[SPEAKER_00] Getting the rest of the internet to actually trust your machine is a completely different, much steeper hill to climb.

[SPEAKER_01] Because you still have to configure your domain registrar and navigate the total alphabet soup of DNS records.

[SPEAKER_01] Let me see if I have the basics of this right.

[SPEAKER_00] Go for it.

[SPEAKER_01] First, you have to set up your MX records or mail exchanger records.

[SPEAKER_01] That's essentially publishing your home address in the global phone book so the world knows where to route messages intended for your domain.

[SPEAKER_00] That's exactly right.

[SPEAKER_00] But that only handles the incoming mail.

[SPEAKER_00] The real challenge is outbound.

[SPEAKER_01] Right.

[SPEAKER_01] Getting past the spam filters.

[SPEAKER_00] Yeah.

[SPEAKER_00] If you want your outgoing emails to actually land in someone's inbox and not vanish instantly into a spam folder, you have to prove your identity to the receiving servers.

[SPEAKER_01] And that requires properly configuring your PTR, SBF, DKIM, and DMARC records.

[SPEAKER_01] We definitely need to translate that alphabet soup for everyone.

[SPEAKER_01] Let's start with SBF.

[SPEAKER_00] Okay, so think of SPF, or sender policy framework, like a VIP guest list at a club.

[SPEAKER_01] Okay, I like that.

[SPEAKER_00] You publish a text record on your domain's DNS that lists the exact IP addresses of the servers that are authorized to send mail on your behalf.

[SPEAKER_01] So when a Google server receives an email claiming to be from my domain, it checks that guest list.

[SPEAKER_00] Exactly.

[SPEAKER_00] And if your server's IP isn't on the list, the email bounces.

[SPEAKER_01] That makes perfect sense.

[SPEAKER_01] And then the sources place a pretty heavy emphasis on DKIM and how Devil supports it natively.

[SPEAKER_00] Right.

[SPEAKER_00] DKIM is Domain Keys Identified Mail.

[SPEAKER_00] If SPF is the guest list, DKIM is a cryptographic wax seal stamped onto the envelope itself.

[SPEAKER_01] How does that actually work under the hood, though?

[SPEAKER_00] It uses public key cryptography.

[SPEAKER_00] When Dovel sends an email, it uses a private secret key stored in your server to generate a unique digital signature for that specific message.

[SPEAKER_01] And it attaches the signature to the email headers.

[SPEAKER_00] Exactly.

[SPEAKER_00] Meanwhile, you've published the matching public key on your domain's DNS records.

[SPEAKER_00] The receiving server grabs that public key and uses it to verify the signature.

[SPEAKER_01] So if it matches, it mathematically proves two things.

[SPEAKER_01] First, the email definitely originated from your domain.

[SPEAKER_01] And second, the contents of the email were not altered in transit.

[SPEAKER_00] Spot on.

[SPEAKER_00] Double handles the hard part.

[SPEAKER_00] Doing the cryptographic math and stamping the outgoing mail by letting you just pass the key path in that simple JSON config file.

[SPEAKER_00] But you still have to manually publish the public key to your domain.

[SPEAKER_01] Got it.

[SPEAKER_01] And what about DMRF?

[SPEAKER_00] DMARC is simply the set of instructions you give the bouncer.

[SPEAKER_00] It tells the receiving server exactly what to do if an email fails the SPF guest list check or the DKIM wax seal check.

[SPEAKER_01] Ah, so you can tell them to reject the email outright, or quarantine it and spam, or let it through but send you a report.

[SPEAKER_00] Exactly.

[SPEAKER_00] And finally, PTR is a reverse DNS lookup.

[SPEAKER_00] It just ensures your server's IP address actually resolves back to your domain name, which prevents spammers from hiding behind anonymous IP addresses.

[SPEAKER_01] So Dovel gives you an incredibly sharp, lightweight tool, but it absolutely doesn't do the plumbing or negotiate with the bouncers for you.

[SPEAKER_01] You still have to prove your identity.

[SPEAKER_00] You do.

[SPEAKER_00] It's a very hands-on process.

[SPEAKER_01] But getting the internet to recognize your server is really only the border patrol.

[SPEAKER_01] Here's where it gets really interesting.

[SPEAKER_01] Once the email actually gets inside the server, Dovel completely uphands the traditional way of sorting it.

[SPEAKER_00] It really does.

[SPEAKER_01] This brings us to what the sources call the Hooks system.

[SPEAKER_00] The hook system is arguably double's defining architectural feature, and it is a radical departure from how enterprise systems operate today.

[SPEAKER_01] Traditional email servers use those massive relational databases we talked about.

[SPEAKER_01] An email comes in, the server queries a SQL database to find the user ID.

[SPEAKER_00] It checks a separate table for forwarding rules.

[SPEAKER_01] Right.

[SPEAKER_01] Looks up storage quotas and then reads the message into a complex database structure.

[SPEAKER_01] Double doesn't do any of that.

[SPEAKER_00] Not at all.

[SPEAKER_01] You just go into your configuration folder, specifically the .config double hooks folder.

[SPEAKER_01] Let's say your domain is double.email and someone sends a message to Joe at double.email.

[SPEAKER_00] Double just looks in that hooks folder for a script file named receive-double.email.

[SPEAKER_01] And if it finds that script, it runs it and passes the raw text of the email directly into the script as standard input.

[SPEAKER_01] I want to make sure we understand standard input or STEM.

[SPEAKER_01] This is a very old school programming concept.

[SPEAKER_00] It is.

[SPEAKER_00] It's the most foundational way programs talk to each other in Unix based systems.

[SPEAKER_00] Imagine a physical pipe.

[SPEAKER_00] Okay.

[SPEAKER_00] Standard input is just the act of pouring data.

[SPEAKER_00] In this case, the raw text of the incoming email into the top of the pipe.

[SPEAKER_01] And the script you wrote sits at the bottom of the pipe, catching that data and doing whatever it is programmed to do with it.

[SPEAKER_00] Exactly.

[SPEAKER_01] So our local mailman doesn't open the mail or try to file it in a massive cabinet.

[SPEAKER_01] He just looks at the domain on the envelope, says, ah, double dot email, walks over to a worker named receive dash double dot email and just hands him the letter.

[SPEAKER_00] That is precisely what happens.

[SPEAKER_00] And that worker script does whatever it wants.

[SPEAKER_01] It is incredibly hacker-friendly.

[SPEAKER_01] You could write a script in Python that catches the email text, reads the subject line, and if the subject says urgent, it sends a text message to your phone.

[SPEAKER_00] or a script that just simply saves the raw text to a local folder.

[SPEAKER_00] You have total programmatic control.

[SPEAKER_01] It's brilliant.

[SPEAKER_00] It embodies the classic Unix philosophy, really.

[SPEAKER_00] Write small programs that do one thing and do it well, and write programs to work together.

[SPEAKER_01] So, Devil just handles the complex SMTP transaction of receiving the mail over the internet.

[SPEAKER_01] What happens to the email after that is entirely up to your scripts.

[SPEAKER_01] I love the flexibility I really do.

[SPEAKER_01] But I have to ask about the reality of scaling this.

[SPEAKER_01] If I have a small business with 10 different users, am I forced to write a massive tangled Python script just to sort the mail into 10 different folders?

[SPEAKER_00] Well, if we connect this to the bigger picture, that is the trade-off of the do-it-yourself modularity.

[SPEAKER_00] However, looking at the project's roadmap in the source repository, they are highly aware of this limitation.

[SPEAKER_01] Oh, good.

[SPEAKER_01] So it's evolving.

[SPEAKER_00] Very much so.

[SPEAKER_00] Dovel is an active development.

[SPEAKER_00] They're currently building out features for multiple inboxes and multiple users, as well as creating HTTP and SSH clients to make accessing that mail easier.

[SPEAKER_01] OK, that makes sense.

[SPEAKER_00] But the beauty of piping data to a script is that you aren't forced into a one-size-fits-all ecosystem while you wait for those features to drop.

[SPEAKER_00] If you need a custom routing rule today, you can build it in five minutes.

[SPEAKER_01] you build exactly your own level of complexity.

[SPEAKER_01] And reading through the Git repository, you realize this script-based bare-bones architecture isn't just some random technical quirk.

[SPEAKER_00] No, not at all.

[SPEAKER_01] It is a direct reflection of a highly specific developer culture.

[SPEAKER_01] The software really tells you exactly who built it.

[SPEAKER_00] The development community behind Dovel absolutely practices what they preach.

[SPEAKER_00] They don't just build this minimalist tool and then go use Gmail for their daily communications.

[SPEAKER_01] No, they are heavily eating their own dog food.

[SPEAKER_01] The sources show the Dovel team uses their own software to run the project's mailing lists.

[SPEAKER_00] Yeah, there's actually a commit logged in the repository from March 5, 2025, by a developer named Murr showing active daily tweaking of the mail instruction scripts.

[SPEAKER_01] They rely on this infrastructure to build the infrastructure.

[SPEAKER_01] And how they handle contributions to the code base is honestly fascinating.

[SPEAKER_00] It is a complete and utter rejection of modern software development norms.

[SPEAKER_01] Right.

[SPEAKER_01] If you want to contribute code to almost any major open source project today, you go to a flashy web portal like GitHub.

[SPEAKER_01] You click a button.

[SPEAKER_01] You use a graphical interface to submit a pull request.

[SPEAKER_01] You leave comments in a web form.

[SPEAKER_00] But not with double.

[SPEAKER_00] You have to use the Git email workflow.

[SPEAKER_01] Which, it's worth noting, is exactly how the Linux kernel itself, the largest open source project in the world, is developed.

[SPEAKER_01] Send an email directly to the repository address.

[SPEAKER_01] The sources instruct you to email server at double dot email and cc the maintainer at double at terminal dot pink.

[SPEAKER_00] And you are explicitly warned to choose your subject line wisely.

[SPEAKER_01] because that subject line literally dictates the conversation threads.

[SPEAKER_01] If you use a sloppy or generic subject, your code patch will break the thread or get lost in someone else's conversation.

[SPEAKER_00] It forces a level of friction that is actually highly intentional.

[SPEAKER_00] Modern frictionless web interfaces encourage rapid, sometimes really thoughtless contributions.

[SPEAKER_00] Having to format a patch, construct an email, properly CC the right maintainers, and manually thread the subject line

[SPEAKER_00] It forces the developer to slow down and think deeply about what they are submitting.

[SPEAKER_01] And speaking of that intentional friction, there is a strict mandate in these sources that I found incredible.

[SPEAKER_01] The project will only accept plain text email.

[SPEAKER_00] Yes, absolutely no HTML formatting.

[SPEAKER_01] No embedded images, no custom fonts, no tracking pixels.

[SPEAKER_01] They are so strict about this that they link out to external tutorials like useplaintext.email and get send-email.io just to teach people how to strip all the formatting out of their email clients.

[SPEAKER_00] This raises an important question about massive digital bloat.

[SPEAKER_00] When we send a standard HTML email today, it uses multi-part MIMB boundaries.

[SPEAKER_01] Let's define that quickly.

[SPEAKER_01] MIMB boundaries.

[SPEAKER_00] Multipurpose internet mail extensions.

[SPEAKER_00] It's the standard that allows an email to contain both a plain text version and a complex HTML version, plus attachments, all wrapped up in one package.

[SPEAKER_01] OK, got it.

[SPEAKER_00] When a marketing email arrives, the actual words, the core message, might only make up 5% of the data being transmitted.

[SPEAKER_01] Wait, really?

[SPEAKER_01] 5%?

[SPEAKER_00] Oh, easily.

[SPEAKER_00] The other 95% is custom styling, hidden tracking pixels to see when you open it, embedded logos, and complex table structures to make it look pretty on a smartphone.

[SPEAKER_01] So the wrapping paper is exponentially heavier than the actual gift inside.

[SPEAKER_00] That is the perfect analogy.

[SPEAKER_00] By enforcing a plain text mandate, the double community violently strips away the wrapping paper.

[SPEAKER_01] It forces a strict focus on the substance of the message rather than the style.

[SPEAKER_00] Right.

[SPEAKER_00] When a maintainer is reviewing a complex code patch, they don't care about the font face or the logo in your signature.

[SPEAKER_00] They only care about the logic of the code.

[SPEAKER_01] So what does this all mean?

[SPEAKER_01] Are we just reverting back to 1990s internet?

[SPEAKER_01] Honestly, it's like listening to a classic vinyl record.

[SPEAKER_00] How so?

[SPEAKER_01] It's uncompressed, pure and there is zero digital fluff getting between you and the actual music.

[SPEAKER_01] This plain text rule perfectly aligns with Double's entire philosophy.

[SPEAKER_00] It really does.

[SPEAKER_01] It demands less bandwidth, less storage, and less processing power, both from the physical server and from the human brain trying to read it.

[SPEAKER_01] It is just you and the words.

[SPEAKER_00] It proves that complexity in our digital tools is often a choice we make, not a strict technical requirement.

[SPEAKER_01] Looking back through everything we've unpacked today, it's an incredibly refreshing perspective.

[SPEAKER_01] Dovel isn't trying to be the next enterprise behemoth.

[SPEAKER_00] No, not at all.

[SPEAKER_01] It is a stripped down, highly efficient gateway to self-hosting your communication.

[SPEAKER_01] It uses a miniscule amount of memory, configures with one readable text file, and leverages standard Unix scripts to route your messages.

[SPEAKER_00] It proves that powerful, secure communication tools don't actually need gigabytes of RAM or massive corporate backing to function beautifully.

[SPEAKER_01] And that realization that you don't need the corporate behemoth to have robust infrastructure is powerful for organizations looking at their balance sheets and their compliance requirements.

[SPEAKER_00] Absolutely.

[SPEAKER_01] Which brings us back to Safe Server, the supporter of today's deep dive.

[SPEAKER_01] We've spent this entire time exploring how lightweight, transparent, and empowering open source solutions like Dovel can be.

[SPEAKER_00] And for businesses, associations, and other organizations, transitioning away from those massive proprietary tools from Microsoft or Google isn't just a fun technical experiment.

[SPEAKER_01] Right.

[SPEAKER_01] It is about realizing massive cost savings and legally securing your data.

[SPEAKER_00] And you do not have to navigate the transition or the alphabet soup of DNS records alone.

[SPEAKER_00] Thank goodness.

[SPEAKER_00] Right.

[SPEAKER_00] Safe Server can be commissioned for specialized consulting to help your organization determine whether a radically simple tool like Dovel or maybe a comparable enterprise-grade open source alternative is the perfect fit for your specific use case.

[SPEAKER_01] And crucially, they operated on secure servers within the EU.

[SPEAKER_01] You can take the first step toward reclaiming your infrastructure by visiting safeserver.de.

[SPEAKER_00] It's definitely worth looking into.

[SPEAKER_01] As we wrap up this exploration of Double, we want to leave you with a thought that builds on this idea of minimalism.

[SPEAKER_01] We've seen how open source developer communities are actively moving back to plain text and minimalistic protocols to save memory, increase speed, and maintain their sanity.

[SPEAKER_00] They are completely rejecting the bloat in their professional tools.

[SPEAKER_01] So how long until we see this philosophy hit the mainstream consumer world?

[SPEAKER_01] Think about your own daily digital life.

[SPEAKER_01] What would a plain text version of our social media or consumer apps look like?

[SPEAKER_00] That's a fascinating thought.

[SPEAKER_01] If we stripped away the heavy algorithms, the endless auto-playing video interfaces and the tracking pixel and just got back to the pure substance of the communication, would our digital lives be poorer for it, or would we finally regain our focus?

[SPEAKER_01] Something to ponder until next time.

[SPEAKER_01] Thanks for joining us.