Blog on Down To Zero

Hosting a static site in a container

Wed, 10 Dec 2025 00:00:00 +0000

Most of our hosted sites are statically rendered, built with tools like Hugo, Zola, or Jekyll. In general, all those site renderers take simplified input (usually Markdown) and generate well-defined HTML as output. This leaves the question: how can I host such a site?

There are specialized providers offering hosting for static sites, but as you know, we took a different path when building our core infrastructure. For our cloud, the common denominator for deployment is a container. And with that comes the question: how can I go from a static site build to a container that hosts the website?

Experimenting with Varlink: Building a Hello World IPC Service

Wed, 03 Dec 2025 00:00:00 +0000

If you’ve ever tried to get different processes on a Linux system to talk to each other efficiently, you know the landscape is… let’s say, fragmented. We have D-Bus, Unix sockets with custom protocols, REST APIs over localhost, gRPC, and countless other approaches. Each comes with its own complexity, tooling requirements, and learning curve.

Recently, I stumbled upon Varlink (and its newer Rust-centric sibling Zlink), and it immediately clicked with what we’re trying to achieve at DownToZero. We’re building infrastructure that needs reliable, low-overhead inter-process communication - from container orchestration to machine settings management. The more I dug into Varlink, the more I realized this could be exactly what we need.

Why Every Object Deserves a Lifecycle: Building Greener Storage with DTZ ObjectStore

Thu, 06 Nov 2025 00:00:00 +0000

Introduction

In cloud development, we often treat storage as infinite. Every log, backup, or dataset we create is preserved indefinitely - not because it’s always useful, but because deletion feels risky. Yet this mindset quietly drives up both cost and carbon impact.

The truth is: most stored objects should not live forever. From transient build artifacts to temporary exports and short-lived analytics datasets, much of the data we produce has a natural lifespan. The challenge lies in aligning that lifecycle with our systems.

Let's Encrypt support for our MCP Server

Sat, 18 Oct 2025 00:00:00 +0000

Continuing our journey with our MCP documentation server from our previous post, we can dig a little deeper into the TLS story, and how we are generating the Let’s Encrypt certificate on startup.

If you want to see the full source code, the github repo is linked at the bottom of the post.

So let’s look a little closer at the details. When we tried to get our MCP server integrated into ChatGPT and Gemini, the requirement for TLS came up. Since we also use Let’s Encrypt all over DownToZero, we mostly reused the process in this container.

Building a MCP Server for Service Documentation

Fri, 10 Oct 2025 00:00:00 +0000

As a fun project, we wanted to expose our official documentation — which is also hosted here — as an MCP server. The idea was to test whether this would make developing our own platform easier, since our AI-based IDEs would have less difficulty checking architectural knowledge against an easy-to-consume public endpoint.

Now, starting very naively, we came up with the following plan to implement this.

As a short teaser, here is what we want to build.

Scale-To-Zero postgresql databases

Wed, 01 Oct 2025 00:00:00 +0000

We always aim to build services as resource-efficient as possible. This is true for the services we offer externally and, just as importantly, for our own internal infrastructure. Many of our internal tools, like billing and monitoring systems, rely on PostgreSQL databases. While essential, these databases often sit idle for long periods, consuming RAM and CPU cycles for no reason.

So, we asked ourselves: can we apply our scale-to-zero philosophy to our own databases? The answer is yes. We’ve developed a system to provision PostgreSQL instances that only run when they are actively being used. This design is incredibly resource-efficient but does come with some trade-offs, which we’ll explore.

Seamless Deployments with the DTZ GitHub Action

Tue, 23 Sep 2025 00:00:00 +0000

Eliminating Wasted Cycles in Deployment

At DownToZero, we’re committed to eliminating waste - whether it’s in compute, energy, or operational overhead. One challenge many teams face in containerized environments is handling updates to container images. Traditionally, deployments often rely on polling for updates when using tags like latest. This leads to unnecessary requests, increased latency for updates, and inefficient resource usage.

To address this, we are introducing a new way to integrate deployments directly with GitHub Actions. With the newly developed DTZ GitHub Action, container image updates can now be pushed directly from your GitHub pipeline into DownToZero. This means no more waiting, no more polling—just immediate, streamlined deployments.

Sync Your Folder to ChatGPT: the story behind `openai-folder-sync`

Fri, 29 Aug 2025 00:00:00 +0000

A while back I kept running into the same problem: I had a bunch of notes, specs, and markdown docs on my laptop, but when I opened ChatGPT and asked questions about them, the model obviously didn’t know they existed. Copy-pasting files was tedious; manually uploading one by one wasn’t much better. So I built a tiny CLI that does the boring bit for me: openai-folder-sync, a command-line tool that syncs a local directory to an OpenAI Vector Store, so those files become searchable context for ChatGPT.

Letting an LLM Review Our Pull Requests (So You Don't Have To)

Fri, 08 Aug 2025 00:00:00 +0000

We love automation. We use it to power our infrastructure, to scale workloads down to zero, and—increasingly—to shrink the amount of human attention needed to ship high-quality code. One place that still felt stubbornly manual was pull-request reviews. Between Cursor as our IDE, ChatGPT/Codex for prototyping, and gemini-cli for quick checks, our local workflows were fast—but CI still waited for a human.

So we asked a simple question: could we let a large language model read the diff, spot issues, and comment directly on the PR?

rss2email: a calmer, faster UI

Sat, 02 Aug 2025 00:00:00 +0000

We’ve refreshed rss2email with a cleaner layout and tighter workflows. The service stays lightweight, but the things you do every day—add feeds, check freshness, tune emails—are now faster and easier.

Live demo: https://rss2email.dtz.rocks/

The dashboard puts rss2email next to your other services for quick access.

What’s new (and why it’s nicer)

A glanceable overview

The FEEDS home shows counts for upcoming notifications (1 day, 1 week, 1 month) plus the total number of subscriptions. It’s the “how noisy will my inbox be?” sanity check.

OAuth Authentication for the Container Registry

Sun, 06 Jul 2025 00:00:00 +0000

Our container registry now speaks the same OAuth dialect as the rest of the DownToZero (DTZ) platform. If you already mint bearer tokens for any DTZ API, you can log in to cr.dtz.rocks with zero extra configuration. This change completes our long-term goal of one identity, one token, everywhere.

Why we added OAuth

The registry originally accepted API keys only. While these keys remain supported, they lack the fine-grained scopes and short lifetimes that OAuth brings. A JWT issued by the DTZ Identity service carries role information such as containerregistry/admin/{context_id} and expires automatically, shrinking the blast radius if it ever leaks.

Introducing Multi-Language Support on the DownToZero Homepage

Sat, 28 Jun 2025 00:00:00 +0000

Today we’re thrilled to unveil a long-awaited improvement to the DownToZero experience: our homepage is now available in five languages. In addition to English you can read every section in German (DE), French (FR), Italian (IT) and Spanish (ES). Whether you’re researching our energy-efficient infrastructure in europe, the content should now feel familiar and approachable in your native tongue.

Why Multi-Language Matters

Cloud technology is global by nature, but language barriers still slow teams down. We constantly heard from users who loved the idea of sustainable, scale-to-zero infrastructure yet found technical details intimidating when presented only in English. By translating our public pages we reduce friction for non-English-speaking builders and make our climate-friendly mission clearer for everyone.

Adding support for Remote MCP Server in our infrastructure

Mon, 16 Jun 2025 00:00:00 +0000

Down-to-Zero (DTZ) has always been about doing more with fewer watts and fewer bytes. From scale-to-zero container scheduling to solar-powered build runners, every service we ship is measured against a ruthless baseline: could this run happily on a fan-less notebook CPU in the sun?

Today we are excited to announce the next step on that journey - remote Model Context Protocol (MCP) servers that you can spin up as lightweight Docker containers inside any DTZ context.

Raising the Bar: New SLOs at 99 % (and 99.9 % for Overall Health)

Sun, 15 Jun 2025 00:00:00 +0000

TL;DR

Metric	Old SLO	New SLO
Any DTZ customer-facing service	95 %	99 %
dtz overall health (aggregated heartbeat)	95 %	99.9 %

The new objectives take effect **1 July 2025** and will be measured over the same rolling 30-day window you already know from the [status page](https://status.dtz.rocks).

Why we’re ready for an extra nine

Over the past year our platform has quietly evolved from “promising” to “battle-hardened”:

Data speaks: Since April 1 we’ve logged 11 production incidents totalling 7 h 28 m of downtime. That’s 99.66 % availability for a 75-day stretch—already above the new global target.
Overall health is rock solid: The aggregated dtz overall health probe has been unavailable for only 16 m in 2025 to date, translating to 99.97 %.
Mean time to recovery (MTTR) shrank 42 % thanks to automatic rollbacks, blue/green deploys and a growing suite of smoke tests.
Observability everywhere: Every critical path now emits RED metrics (rate, errors, duration) and SLO burn alerts feed directly into on-call slack channels.

What changes for you

Tighter error budgets. With 99 % availability a service may now be down for ~7 h 18 m per month (previously ~36 h). For the 99.9 % overall-health check the allowance is just 43 m.
Faster incident response. Pager thresholds are being shortened from 3 m to 60 s of failing probes so we can act before you notice.
Transparent credits. If we breach the SLO, service credits will land automatically—no ticket required. The updated ToS goes live next week.
Richer public telemetry. Latency percentiles and burn-rate graphs will be added to each component on the status page so you can correlate issues with your own dashboards.

How we’ll stay inside budget

Redundant probes from three regions for every heartbeat.
Instant deploy rollbacks. 90 % of reversions already complete in under three minutes; the goal is sub-one-minute.
chaos drills keep recovery playbooks fresh.
Sustainable ops, not wasteful ops. We continue to run on carbon-aware schedules; more nines do not mean more megawatts.

A quick look at the numbers

Since 1 April 2025 we have seen:

Physical locations of our datacenter

Fri, 06 Jun 2025 00:00:00 +0000

At Down To Zero (DTZ) we believe a modern cloud platform can — and should — be both blazingly reliable and gentle on the planet.
Our answer is a twin-site architecture that pairs a private, solar-powered micro-datacenter in Leipzig with a fully redundant footprint inside Hetzner’s flagship facility in Falkenstein. Together they give us three things every customer cares about:

Consistent performance (low-latency paths inside Germany)
Provable sustainability (100 % renewable energy, measured & monitored)
Fault tolerance (geographic isolation, automated fail-over)

Below we dig into the what, why, and how.

Introducing Our CustomGPT: A Powerful New Addition to the DownToZero project

Sun, 16 Mar 2025 00:00:00 +0000

We’re excited to announce a groundbreaking addition to our help support the DownToZero project: a CustomGPT. This new feature takes our technical documentation and support capabilities to the next level, enabling you to streamline workflows and get answers faster than ever. Below, we’ll walk through how CustomGPT works, highlight its key benefits, and show you why we believe it will become an indispensable tool for your DownToZero projects.

⸻

What Is CustomGPT?

CustomGPT is a specialized, AI-driven chatbot that goes beyond simple Q&A. Powered by advanced natural language processing, it is trained on our comprehensive DownToZero documentation. In addition to explaining our docs clearly, CustomGPT has two standout capabilities:

How to log into the container registry

Wed, 26 Feb 2025 00:00:00 +0000

Preparations

Before you can use the DTZ container registry, you need to enable the service first.

Enable the service

Access the container registry dashboard

Container Registry Dashboard

Testing the registry endpoint

You can click the link on the dashboard to test your registry instance. This link should lead you to the following page.

After completing the setup, you need to retrieve your instance URL from the container registry dashboard, in this case, https://66fc19af.cr.dtz.dev/.

Using DTZ Objectstore for Terraform state files

Sat, 28 Sep 2024 00:00:00 +0000

We use Terraform a lot either to test our own infrastructure or deploy projects within DownToZero.

Since DTZ is supported as provider we started implementing projects on top of it. One thing that regualarly was coming up is the location of the state file. Checking the state in the git repo is usually not a good idea (although it still better than keeping it local), but having some for of remote state helps a lot with running TF in pipelines and making the state independent of the project.

Worker Node Setup of DownToZero

Mon, 23 Sep 2024 00:00:00 +0000

Last year we already did a blog post on the hardware setup of DownToZero. Since then we are using the same setup for a while now and wanted to share an update.

Energy consumption

Since we decided to purely use notebook chips, our energy consumption is significantly lower then desktop machine. Also our mode to only power the machine during times that solar power is available lead us to near zero power grid consumption.

Implementing our own Terraform provider to allow infrastructure automation

Thu, 12 Sep 2024 00:00:00 +0000

We started implementing our own Terraform provider since we think automation is key to cloud adoption.

You can find our provider at github under

https://github.com/DownToZero-Cloud/terraform-provider-dtz

and over at the Hashicorp terraform site:

https://registry.terraform.io/providers/DownToZero-Cloud/dtz/latest

This provider give every customer another path of accessing DTZ resources and implemting their automation/IaaS on top of our services.

To setup the provider you need to generate an API-key through the website. We currently only support apikey authentication.

A non-technical explanation of DownToZero

Fri, 12 Jul 2024 00:00:00 +0000

From time to time, we get the question of explaining DownToZero and what makes it stand out from other cloud services to non-technical people. We’ve tried various explanations, but we found an analogy that resonates with most people. We wanted to share it here to make our principle accessible to more people.

After a long workday, you are driving home. Arriving at your house, you pull into your driveway, turn off the car, and go into the house. Even if you plan to go shopping later that day, you still turn off the car because leaving it running seems wasteful.

Re-packaging the Swagger UI as a Rust module

Tue, 21 May 2024 00:00:00 +0000

All our services need to have a Swagger UI for presenting its current OpenAPI file to the user. Since our backend is completely built with Rust, hosting this Swagger UI is also done through a Rust process.

So to make the Swagger UI a first degree citizen in the Rust ecosystem, we decided to re-package the Swagger-UI as Rust module. This way, dependabot can pick up update to the underlying project und pull those dependencies into our projects.

[new feature] Status page added

Fri, 10 May 2024 00:00:00 +0000

To further improve our offering we intruce a status page to our stack. This page is externally hosted, so it will keep running even if everything else is failing.

This will provide a single entry point for communicating issues and provide transparancy when service failed.

status.dtz.rocks

Building our own nodes

Sun, 10 Sep 2023 00:00:00 +0000

Ever since we started measuring our energy demand, we also started to develop concepts on how we could improve energy efficiency. Customizing our own machines more then just the software seems obvious, but it is also easier said then done.

First we had to look out on what hardware we want to build upon. Most cloud providers start with rather heavy workload machine and are optimising for peak load. Our setup was different and we wanted to move the needle on the low end, not the high end. That meant that traditional servers were not really in scope for this task. Looking around the market, something between small form factor ARM or RISC-V machine seemed like an easy choice. sadly getting those machine into a more server like setup takes quite some preparation. Also we saw 2 properties missing from all of those setups.

Metrics for calculating the cost of processing

Sat, 19 Aug 2023 00:00:00 +0000

Every cloud platform must have some metric of cost assiciaated with its services. For most public cloud offerings, the target metrics for cost are usually CPU core count and amount of memory. That gets multiplied by the amount of time used and we arrive at usage-based pricing.

This model has its pros and cons, so let’s iterate a little over this.

The Pros

Since all cost is tied to a usage pattern, the goal ist to reduce cost by reducing usage.

Server Timing on all Endpoints

Sun, 07 May 2023 00:00:00 +0000

Since we can only improve on what we measure, we started implementing the Server Timing API on all HTTP endpoints.

The API provides simple means to extend the http header with some performance measurements.

For some general introduction into the topic you can check the mozilla documentation on it (https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server-Timing).

As for the actual implementation, we use the following Rust implementation, which provides us with performance data for axum server out of the box, (https://crates.io/crates/axum-server-timing).

A Solar Powered GitHub Runner

Sat, 15 Apr 2023 00:00:00 +0000

The more our little project progresses, the more code we produce. And like most of our community these days, we host our code on GitHub.

So during development we discussed the implications of a DownToZero architecture for something like a GitHub process. We quickly identified two types of actions that need to be performed on the infrastructure.

The first is the CI build, which should always provide immediate feedback to the developer. It checks for compliance as well as code integrity and is usually deeply involved in the development process. These jobs are time-sensitive because someone is usually waiting for them.

RSS a better decentral alternative

Thu, 05 Jan 2023 00:00:00 +0000

Why RSS is a decentralized, open-source subscription method superior to centralized options like social networking.

In today’s digital world, it can be easy to get overwhelmed by the vast amount of information available online. Using a subscription service is one way to stay organised and keep track of the content that interests you. There are a number of different options, including social media networks and RSS feeds. In this article, we’re going to take a look at why RSS is a better decentralised, open-source system for subscribing to content than centralised alternatives such as social networks.

scale-to-zero with containers

Mon, 02 Jan 2023 00:00:00 +0000

Scale-to-zero architectures have gained popularity in recent years as a way to optimize resource utilization and reduce costs in cloud-based deployments. In a scale-to-zero architecture, idle resources are automatically scaled down to zero, freeing up resources and reducing costs. This is in contrast to traditional architectures, where idle resources are still allocated and consuming resources, even if they are not actively being used.

One way to implement a scale-to-zero architecture is through the use of containers. Containers are lightweight, isolated environments that allow developers to package their applications and dependencies into a single unit, making it easy to deploy and run applications in any environment. Containers have become a popular choice for deploying cloud-based applications due to their portability, scalability, and ease of use.

[new service] rss to email

Tue, 13 Sep 2022 00:00:00 +0000

Under the umbrella of our flows service, which provides easy to use integration services, we implemented a RSS to Email (RSS2Email) service.

After enabling the service within a context, you can access the service through header field.

First thing that has to be filled is the target email address. All notification will go out to this single adress. If you want to send certains feeds to another address, you need to open a new context.

added some documentation

Tue, 08 Mar 2022 00:00:00 +0000

One Year in and progress is still slow and steady. this month we added a documentation page to the site. This way the changes will be more transparent and easier to follow.

time for a new perspective

Tue, 02 Mar 2021 00:00:00 +0000

IT infrastructure has become cheap. Building a highly available system with multi-machine, multi-datacenter, even multi-regional architectures can be easily achieved with just a credit card. Building fast-performing systems on top became the defacto standard for computing and data storage. Today more and more effort is put into vertical and horizontal scaling to achieve lower latency and to reach customers faster. And while in general, this is a good idea, the cost for these kinds of architectures is not just money. Scaling a ‘simple’ website to a multi-regional approach can easily take tens of machines, all always on, all ready to perform on the incoming requests.