100 Changelogs: Five Years, One Mission.
A note from Laura & Max
This is our 100th changelog, and it lands just a few months after Epsilon3 turned five. We've shipped a release every couple of weeks for five years, through hardware that had to fly, audits that had to pass, and programs that couldn't survive a missed step. What 100 really means to us is that 100 times, one of you told us where your work still broke, and we shipped something to fix it. As we mark this milestone, we wanted to take a moment to look back at where this started, where we are now, and where we're going, and to thank the people who got us here.
Where we've been.
I (Laura) started Epsilon3 because I was frustrated with my tools. Through my time at SpaceX, over those years I authored, tested, and ran hundreds of procedures for the crews and the ground teams, including the missions that put American astronauts back in orbit from U.S. soil. The work that mattered most from the steps, the verifications, the sign-offs, to the conditions that had to be true before you moved on, ran on software nobody had built for it. The drawings sat in one system, the parts in another, and the actual procedure lived in spreadsheets, PDFs, and the heads of the few people who'd run it enough times to know where the wires really went. So I built the tools I would have wanted if I were still on the console, piece by piece.
The vision, at the start, was almost stubbornly small: the procedure deserved to be the system of record. Not a document that described the work, but the work itself, a live, accountable, and trusted enough to bet a mission on. We built it as operators, not as software people guessing at what operators need, but as the people who'd lived the 3 a.m. procedure and the failed sign-off ourselves. Our very first changelog, in March 2021, shipped telemetry, commanding, and access permissions. We didn't have a name for the category yet, but the idea was already there: live data, real control, and a record of who did what. For a few years we made that one thing great: a procedure your team could run together, live, with every step accounted for. The thread we cared about ran straight through a team: planner, operator, reviewer, same source of truth, in real time.
I (Max) came at the same problem from a different direction. I've been drawn to space and aviation for as long as I can remember. There's no sharper reminder than a cockpit that in high-stakes environments, the procedure is the job. My career, though, ran through software. I studied computer science at Stanford, spent three years as an engineer and tech lead at Google, and co-founded multiple startups before this one. Over time I came to understand where software has the most to offer: at its intersection with the physical world, a place you only really see through hardware. That's what eventually pulled me into defense, where I co-founded Epirus, a counter-drone company building hardware for some of the highest-stakes environments there are.
What I took away from building defense hardware was almost counterintuitive. The biggest leverage in this industry wasn't in making more hardware but in the software that the hardware actually runs on. Everyone had modernized the tools around the work. But the work itself, the procedures, the actual steps people execute when a spacecraft is on the pad or a line is running on the floor, was still stuck on paper and spreadsheets. It didn't matter whether you were launching a rocket or building a satellite; the most critical moments were the least supported.
Laura and I are, in a lot of ways, two halves of the same problem. She spent her career inside the work, running operations and living the consequences of a missed step or an out-of-date procedure firsthand. I spent mine building software and hardware from the other side, learning where technology genuinely moves the needle and where it just adds noise. She knows exactly what operators need because she was one; I know how to build the kind of trust-grade software those operators will actually depend on. Epsilon3 sits right at that intersection, operator instinct and engineering discipline, and that pairing is why we think we can finally fix the part of these industries everyone else built around and left behind.
Where we are today.
Five years is a long time to do anything every two weeks. Long enough that the company grew up around the changelog. The team that ships this has, over those five years, celebrated more birthdays than we can count, welcomed new babies, gotten married, moved across the country, lost people they loved, and showed up the next morning to ship anyway. A startup isn't a logo and a roadmap; it's people's actual lives, pointed at the same problem for a long time. We don't forget that the reliability you count on from the platform was built by humans having very human years.
And here are the results: more than 350 features and over 1,000 improvements and fixes, across these 100 changelogs and 200-plus releases. More than 6,000 feature requests logged from your teams, and the honest truth is that the large majority of what we built started life as one of them, not as our idea. More than 130 organizations now run on Epsilon3, from two-person prototypes to programs you'd recognize. The teams behind roughly a third of U.S. orbital launch providers run on Epsilon3. We pursued and earned FedRAMP High, one of the highest levels of confidence in our security and compliance posture in the industry, because the programs you run can't live on tools that won't meet you where you operate. And you've handed us more than 40 G2 leadership awards across 12 categories, which we value immensely, because they come directly from you.
The industry didn't sit still while we built. These five years moved through explosive growth, real conflict, and a national urgency to build and field hardware faster than the old tooling was ever meant to support. The ground shifted under everyone in aerospace, defense, and manufacturing, and the teams doing the work absorbed most of that shift themselves. We built through it by holding to three things: move fast, cover the real breadth of the work, and stay ruthlessly focused on what operators actually need. Speed and breadth without focus is just bloat with a nicer changelog. We tried hard not to build that.
We won't pretend we got it all right. Across 350-plus features and a thousand-odd fixes, plenty of them missed. We shipped things that landed with a thud, guessed wrong on what mattered next more than once, over-built things nobody asked for, and were slower than we should have been on things you asked for repeatedly. The cadence matters to us so much because it isn’t just our commitment to ship a lot, but that we will ship a lot and correct quickly every two weeks. When we got something wrong, you told us plainly, and we'd rather change course in public than defend a bad call. A lot of what's good about the platform exists because a customer was kind enough, and blunt enough, to tell us we'd missed.
Somewhere around changelog #49, in the summer of 2023, the vision grew up too. We stopped being a procedure tool and became a platform: plan, build, execute, analyze, the work that used to need three disconnected systems started living in one. Builds, parts traceability, test management, quality, requirements, reports. We built every one of them because a customer told us their thread broke right there. The conviction underneath it never changed from day one: one connected record for the whole operation, not another silo bolted onto the pile.
We just put out our first State of Operational Readiness report — we surveyed 513 of you — and the data said exactly what we built this company on: the work itself is the last unmodernized layer of the stack. Half of all cross-team communication still moves by hand. In 42% of organizations, even "task complete" travels by email. Capable teams are holding fragile systems together, and they know it.
Where we're going.
Here's what 100 changelogs taught us about the next 100. The thread we started with ran through a team, now we’re going one step further, deeper into what teams need across the lifecycle of building complex hardware, and broader across the needs of collaboration between organizations.
Deeper, because the procedure was never the whole job. It's the heart of it, but around that heart sits everything a hardware team has to do to get something built, tested, and flown: plan the work, build the hardware, run the tests, source the parts, track the inventory, maintain it once it's in the field. For most teams, every one of those still lives in a separate application, lashed together with brittle integrations and the one spreadsheet bridge a single person quietly keeps alive. Every seam between those tools is a place the thread can snap and a place a team gets fragmented. We're building best-in-breed depth for each of those jobs into one connected surface, with the procedure at the center holding it together. Not a dozen systems that each believe they're the source of truth. Fewer applications, one connected thread, one control surface that actually is.
Broader, because your work doesn't stop at the edge of the team, or the edge of the organization. The procedure runs on the prime's system, the subcontractor can't get in, so the work gets exported to a PDF, emailed, signed by hand, scanned, and re-keyed on the other side. The hardest handoff you have isn't between your teams. It's between your organization and everyone you build with. That's where the thread gets cut today. So we're extending it across the boundary, too: the same connected record that links your planner to your operator should link a prime to its suppliers, a manufacturer to its customer, an integrator to its partners without dragging everyone onto one instance, and without tearing down the walls that keep your data yours. Controlled, scoped, logged access where there used to be an email chain. We've been seeding this quietly for a while (cross-organization sharing first shipped back in changelog #92, for the eagle-eyed among you) and it's where the whole platform is now headed.
If Epsilon3 1.0 was the connected thread inside a team, Epsilon3 2.0 is the connected thread across the whole hardware lifecycle, and across the organizations that share it. Same idea, deeper roots and a wider radius: the work is the record, the record lives in one place, and it should follow the work wherever it goes.
One more thing.
All of this came from you telling us where your work still broke and us shipping a hundred times over to find solutions. We don't take that responsibility for granted. We know you have other options, and that every release only provides you value if it makes your work easier, safer, or faster. So thank you, to our customers, for the 6,000-plus requests, the honesty, and the trust to run your most important work on what we build, and to our team, for building it alongside you, through five years of ups and downs, to the standard you hold yourselves to. We're still operators at heart, we're still learning from you, and we still get a little thrill every other week when we ship something new.
Here's to the next hundred. Onward.
Laura Crabtree, CEO & Co-Founder & Max Mednik, COO & Co-Founder