Lessons learned from commercializing dev infrastructure
Table of Contents
Some readers of this blog will know that before Earthly Lunar, we built CI infrastructure tech. The road to Lunar’s success hasn’t been straight. In fact, it’s been pretty bumpy, with lots of lessons learned along the way.
This is the story of how we failed to commercialize the next-gen CI technology we’d envisioned, what we learned in the process, and how we incorporated those lessons into a successful pivot toward engineering guardrails infrastructure.
TL;DR
- A self-managed, persistent build environment could deliver enough of the speed benefits of Earthfiles that some teams had little reason to buy Satellites, our managed build runners.
- Developers who adopted Earthfiles for consistent builds weren’t necessarily looking to spend money on faster CI. Broader adoption also required migration work that organizations struggled to prioritize.
- Interviews exposed a company-wide problem: even straightforward fixes could sit unmerged for quarters because teams struggled to test and adopt them. Lunar’s central instrumentation lets platform teams evaluate and enforce standards without waiting for repo-by-repo integration.
- That changed the commercial approach too. We address a problem engineering leaders already own, with a budget they control, instead of relying on organic adoption to eventually reach a buyer.
The free product changed what we could charge for
We built Earthfiles to make builds consistent and fast. Our plan was to make the build tool useful for free, then charge for Satellites, managed remote build runners that kept build caches between runs. Developers adopted Earthfiles, but we couldn’t turn enough of that adoption into revenue to sustain its development.
A team could get faster builds and never become a paying customer. That was a reasonable way to use the software we’d given them. It was also a problem with the business we’d designed around it.
Earthfiles let developers experience the full speed benefits locally. Satellites offered a way to reuse cache between CI runs, including when the CI jobs themselves ran in ephemeral environments.
But a team could also keep its own build environment around. In our 2025 shutdown announcement, we described users moving from ephemeral CI environments to persistent ones to get those benefits without buying Satellites.
That setup still needed someone to operate it. The purchase decision was whether our commercial service was worth more than the work of managing their own installation. We couldn’t attribute all of the time savings from Earthfiles to Satellites when a team was already getting much of that value for free.
We noticed users gravitating toward persistent runner setups on platforms like Jenkins and Buildkite, where the build environment and cache could survive between jobs. In those setups, we saw CI builds run 2–20× faster with Earthfiles. That’s a huge improvement, and users could get it on infrastructure they operated themselves.
Satellites provided that speed too, with a managed service that spared teams the complicated cache setup and tuning. But once they had the DIY setup working, that convenience was a nice-to-have. They already had the speed improvement that made the product compelling. We were asking them to pay to make it easier to operate.
I would have considered the same option. An engineer working within a fixed infrastructure budget has good reasons to use the tools already available to them. We were responsible for offering something worth the additional spend.
There was a second mismatch, which we’d already described in our 2023 retrospective: much of the community came to Earthfiles for consistent builds. We were trying to sell fast builds. Someone willing to learn Earthfiles to make a build behave the same locally and in CI wasn’t necessarily looking for a paid CI performance product.
Adoption had its own cost
At the same time, we struggled to get organizations to adopt Earthfiles broadly. An engineer trying it on one project was a different commitment from an organization introducing it across its build infrastructure.
The existing scripts might be unpleasant, but they worked. Replacing them required learning Earthfiles, adapting the build, and checking that the new setup preserved the behavior people depended on. That work had to compete with everything else on the team’s schedule. The eventual time savings didn’t make the migration free.
New prospects weighed migration costs against the benefits we promised. Teams already using Satellites had fast builds without giving up their existing CI integrations and workflows. Asking them to replace more of that infrastructure required a reason beyond speed.
We asked about priorities and heard something else
In the summer of 2024, before that shutdown decision, we started interviewing platform and engineering leaders and practitioners. We wanted to understand how Earthfiles could serve larger organizations. We expected build speed to feature prominently.
We spoke with more than 100 distinct teams, starting each interview with the same question:
What are the top issues that you’re struggling with in your day-to-day work?
Only one team named build speed as a top issue. They’d recently had a production incident where a slow end-to-end CI/CD process delayed getting a fix out.
That made us question our plan to sell build speed.
What surprised us was how difficult even basic changes were at scale. We heard about CI template updates sitting unadopted even after someone had done the work and submitted a PR. Teams could lag behind for quarters, sometimes years, on changes that looked straightforward from the outside.
Writing the patch didn’t finish the work. Different teams had very different levels of DevOps maturity, and testing the change wasn’t always easy. A central team could identify the problem and contribute a fix, then still have to wait for the owning team to validate and adopt it. Multiply that across an organization and a routine update became a long-running coordination and migration project.
This changed how we thought about adoption. Asking every team to move to a common workflow would introduce another rollout with the same dependencies. Even asking each team to merge an integration PR could leave the platform team waiting indefinitely.
A common standard does not require an identical workflow
Consider a requirement that production services have readiness probes. One team gets them from a shared Helm chart. Another uses a different chart. An acquired service has its own deployment process. A temporary exception outlives the incident that justified it.
The requirement can be the same across those services. The evidence needed to check it comes through different paths.
Even a single CI vendor leaves plenty of variation: wrappers, test frameworks, pipeline structures, and overrides. A check that works for the shared workflow may miss everything outside it. Moving everyone onto that workflow creates another rollout to manage.
This changed the technical problem we wanted to solve. Collecting and interpreting evidence across existing workflows had to be part of the product. Otherwise, we’d be handing the platform team another integration project before it could get the answer it needed.
Central instrumentation was the technical breakthrough
We needed to help teams with the infrastructure they already had. The platform team had to be able to establish visibility and enforce standards without first persuading every application team to adopt another tool or accept a contribution. We couldn’t find a solution out there that did this.
That became the basis for Lunar. We could instrument repos and CI centrally and turn engineering standards into automated checks, or guardrails, without waiting for each team to integrate anything.
The setup happens at the repo-access and CI-runner level, where the platform team already operates. Making sense of all the different pipelines became our engineering problem, instead of a migration project we handed back to the customer. Teams would still have to fix issues we found, but they didn’t have to adopt a new workflow before the platform team could see what was happening.
AI adds another place the standard has to hold
An AGENTS.md file can explain a requirement and why it exists. The platform team still needs to know whether the current instructions reached the relevant projects and whether the resulting change satisfies the requirement.
Objective requirements can be expressed as executable checks that return specific feedback. In Lunar, agent hooks let those checks run while an AI agent is working and return failures for it to address. The same checks also run on pull requests, so the platform team doesn’t have to maintain a separate version of its standards for AI-written code.
A configuration check can help during authoring when the relevant files are available. A requirement based on completed tests has to wait for those results. Missing evidence needs an explicit outcome.
A repeatable check also has limits. Finding a readiness probe in a manifest doesn’t establish that it measures readiness accurately under load. Engineers still own the requirement, the exceptions, and the judgment about whether a change solves the right problem. That holds whether a human or an AI agent wrote the change.
That brings us back to the same organizational problem: the platform team is responsible for standards across the company, even as individual teams change how they work. AI adds another workflow to account for, but the need to apply those standards consistently already existed.
What we carried into Lunar
With Earthfiles, we hoped adoption would spread from individual engineers until it led to an organization buying Satellites. An enthusiastic user could be a long way from someone with a budget, and the person with the budget might not consider faster builds a priority.
The problem we’d heard in the interviews already belonged to platform leadership. They were responsible for getting changes adopted across the company and felt the cost when that took quarters. They also controlled the budget to do something about it.
So we could work directly with the people who owned the problem. They could decide to use Lunar and set it up centrally, without first finding an engineer on every team willing to champion it. With Earthfiles, we’d needed those individual advocates to get a broader rollout going.
Earthfiles had engineers willing to learn it and build with it. We owed them a business that could sustain that work. Understanding where we went wrong gave us a better starting point for Lunar, but we still had to establish who owned the problem, what they were already doing about it, and whether we removed enough work to justify bringing in another product.
That’s what I wish we’d understood earlier with Earthfiles: there’s pain, adoption work, and budget. The pain was real, but the engineers who felt it weren’t necessarily the people who controlled the budget. When getting budget was harder than working around the problem, they made DIY setups work, imperfections and all. Getting the product adopted across the organization was a separate undertaking. With Lunar, we brought those three things closer together: the platform team feels the pain, can adopt the product centrally, and has the budget to pay for it.


