Explorer Pattern: Imprint’s Way to Build Products

Explorer Pattern diagram showing writers feeding one primary database that fans out to replicas

Imprint has given a name to the way it now builds new products: the Explorer Pattern. One person or a small team builds a working version of a feature with as little coordination as possible, then settles the details with other teams once the prototype exists. The company accepts that this can mean heavy rework.

Imprint used to call the approach “Tech-led” or “Engineering-led” development, labels that left many colleagues unsure what they meant. The new name comes with a fuller definition and a set of working rules.

Why Imprint changed its process

Before 2026, the thinking goes, code was expensive, so companies designed process to limit implementation and rework. Engineering was treated as the scarcest resource, and common habits followed from that, such as bringing engineers into a problem late “to protect their time.”

Imprint argues that is no longer the right assumption. Writing software is now very cheap, and so is reworking it. The same holds for other output: code is nearly free when the right constraints exist, designs are nearly free when they follow patterns, and analysis is nearly free when things are properly instrumented.

The company also says working on the system beats fixing one-offs, provided automated integration and feedback loops are in place. Improving a design system, for example, beats polishing a single design. If improving the shared process is slower than solving the one-off, Imprint treats that as a bug in the process.

Database replication diagram: three Writer boxes feed a single Primary database, which fans out to a chain of Secondary replicas
Image: lethain.com

The database replication comparison

The easiest way to picture the Explorer Pattern is database replication. In MySQL and PostgreSQL, one primary database takes the writes. Each write is verified there, then flows to secondary replicas. Replicas can lag, but they can’t be wrong, because the checking happened upstream.

Systems such as Dynamo and Cassandra, and to some extent MongoDB, work differently. A write needs acknowledgement from a majority of a replica set to be strongly consistent. That setup tolerates the loss of a node, but it brings inconsistencies and, on the same hardware, tends to run much slower than a primary-secondary design.

The Explorer Pattern follows the primary-secondary model. The working person or team does most of the work, so everything stays internally consistent because it passes through one small group. That doesn’t make it perfect. A database will accept the number 200 as a valid integer even if the credit limit was never meant to be 200. Whether a value is right depends on the surrounding application logic.

Other teams hear about changes downstream rather than up front. The working group has to explain its approach and keep its progress visible so others can engage without blocking it.

Diagram of three Writers writing to three separate Primary databases, with the write paths crossing and tangling to show inconsistency
Image: lethain.com

A real case: financial aggregator support

Imprint’s example is support for financial aggregators, which lets people connect their Imprint-powered accounts through Plaid. Customers have wanted it for a while, and it matters more as agentic commerce grows and more people’s agents analyze their finances for them.

Ron, one of the company’s engineering leaders, built the first version at low burn in a private alpha while he worked out the shape of the problem. He updated other teams now and then, but it was a side project. Once he had a full solution, Imprint cut the lag between teams to near zero, worked through the few remaining issues and shipped. Like many of the company’s projects this year, it was never officially on a roadmap.

The rules for explorers

  • Know the goal and the sponsor. Past roughly three weeks of effort, the team should be able to name who is backing the project. If it can’t, it is closer to lost than exploring.
  • Keep the group to five people at most, preferably fewer, so everyone can hold the whole project in their head.
  • Look for a way to yes. Exploring means finding the real shape of a problem, not pretending it is already known.
  • Publish progress in a public channel. At Imprint that means a Linear project plus a Slack channel.
  • Make the narrowest changes to what already exists. Needless changes break other people’s mental models and imply a deliberate reason that discourages later improvement.
  • Discard bad ideas fast, then test the rest by implementing them as quickly as possible.
  • Hold assumptions constant. Headcount planning needs revenue, which needs a forecast, which needs go-live dates nobody knows. A plausible guess unblocks the work, and heavy prework only adds false precision.
  • Stay open to being totally wrong, including starting over a second, third or fourth time.
  • Ship all the way to production behind a feature flag enabled only for internal users.

What teams should take from it

The Explorer Pattern accepts a real cost. Rework can be large, and other teams see the work late. Imprint’s bet is that cheap code makes that price worth paying, because a working prototype settles arguments that planning documents leave open.

Teams weighing the approach can start with the feature-flag rule and the public progress channel, which are the cheapest to adopt. The group-size cap and the sponsor check are what keep an exploration from drifting into an unmanaged side project.

Source: lethain.com

Written by

Saksham Bhargava

Saksham Bhargava runs Alteroid and has been writing about consumer technology for over five years, covering iPhone, Android, Windows, AI tools and gaming. With an MCA and six years of hands-on web development experience, he tests the features he writes about on his own devices and focuses on clear, practical guides that solve real problems. Away from the screen, he enjoys travelling to places most tourists skip.