Back Arrow

Meticulous Announces $4 million Seed Round to Help Developers Make the World's Code Safe, Performant and Reliable

Meticulous Announces $4 million Seed Round to Help Developers Make the World's Code Safe, Performant and Reliable

By Gabriel Spencer-Harper, founder

I am thrilled to share that Meticulous, a Y Combinator startup, has closed a $4 million Seed Round to build the first automated front-end testing software for developers. This capital will accelerate Meticulous’s mission to radically accelerate the pace of software development for every company in the world.

Our investors include Coatue, Soma Capital, Base Case Capital and Y Combinator. We also continue to be supported by our incredible angel investors, including Jason Warner (CTO GitHub), Scott Belsky (CPO Adobe), Guillermo Rauch (founder Vercel), Calvin French-Owen (founder Segment), Jared Friedman (YC Partner), JD Ross (co-founder Opendoor) and Lachy Groom (Stripe).

Our Founding Story

During my time as a software engineer at Dropbox and Opendoor, I discovered that however much you unit or integration test your code, you tend to find that actual users of your application find a way to break it.

At Dropbox, our engineering team would sit in a meeting room for hours to manually test the same workflows, week after week. This testing was effective, but time-consuming. Alternatively, we invested in automated end-to-end tests, but these involved huge amounts of mocks that are painful to write and tedious to maintain.

This prompted me to think about building a testing product for software engineers with zero setup and zero maintenance burden. Especially as I witnessed our engineering team at Dropbox throw away the recordings of our bug bashing sessions each week, I thought “what if there was a way to turn these into automated tests?”

This is how the idea for Meticulous was born – a first-of-its-kind software to automatically detect regressions in web applications with zero-effort from developers.

Meet Meticulous

Meticulous’s goal is to record thousands of sessions and simulate those on new code to automatically catch bugs before they hit production.

In the future, when a developer submits a code change, Meticulous will show them all the runtime information about that code: exceptions it introduces, visual differences in the UI, the performance impact, how many users it impacts and other runtime information. Imagine hovering over a line of code in your IDE and seeing its performance characteristics before it has ever been released into production.

Building this requires solving many intricate technical problems, so we’re developing Meticulous in stages. Our first product is a tool that makes it easy for engineers to write end-to-end tests. Developers can now use our CLI to open an instrumented browser that records their actions and translates these into a test.

Watch the demo here.

Why Now

Only huge companies have the resources and enough engineers to build out automatic regression detection. Twilio invested heavily into implementing a system like this in the early 2010s. Google has a system still in use today, which diffs visual snapshots. For hundreds of thousands of smaller companies, however, developer teams are left on their own to create robust low-maintenance testing suites.

One of the biggest problems for smaller developer teams simulating end-to-end user flows on a production environment is that it will cause side effects. In order to overcome this, companies will often spin up a staging environment. However, building a staging environment that is representative of production is a tricky problem in and of itself. Furthermore, companies’ must implement a mechanism to reset state after each simulated session (imagine simulating a user signing up to your web application).

Meticulous captures all network traffic at record-time and automatically mocks out all network calls at simulate-time. This isolates the frontend, avoids causing any side effects and allows any company to implement testing for their frontend code without any backend environment. This feature can be toggled off for stateless flows or for companies with a staging environment who want to test throughout the whole stack.

Try Meticulous here.

What are our Investors Saying

“The demand for software has outpaced the tooling to support developers. Meticulous is a solution to help front-end developers build more robust software that is safe and reliable as they build the future of our web-based economy. Coatue sees great potential from the early team Gabriel is leading and we look forward to supporting Meticulous’s evolution.” - Andy Chen, General Partner, Coatue

“I spend the majority of my time with engineers — listening to their pain points, understanding their motivations, and helping connect them with relevant startups. Over and over, I hear the frustrations that come with creating and maintaining UI tests. For high velocity teams who want to build and ship valuable products to their users, UI tests are quite frankly a pain in the butt, yet shipping those products with bugs can cost you. Meticulous has assembled one of the strongest software engineering teams that we've seen, and I’m excited to see them build a product that automatically detects regressions in web applications, so that engineers can go back to focusing on what they do best: building.” - Alana Goyal, Base Case Capital

"Regression testing as a whole, especially in an automated manner, remains a pressing challenge for engineering teams; particularly for those within companies that haven’t reached the scale to build in-house solutions. With Meticulous, teams are able to streamline the deployment of code and product launch, sans the bottleneck of timely UI tests The Soma team stands excited by the robust UI testing tool in development and looks forward to continuing to support Gabriel and the Meticulous team in their execution." - Aneel Ranadive, General Partner at Soma Capital

Why Meticulous?

Learn how to catch UI bugs without writing or maintaining UI tests
Try it now

Meticulous is a tool for software engineers to catch visual regressions in web applications without writing or maintaining UI tests. Meticulous isolates the frontend code by mocking out all network calls, using the previously recorded network responses. This means Meticulous never causes side effects and you don’t need a staging environment.

Ready to start?

Set up in minutes and generate tests to cover your whole application.