Fetch

Fetch wanted to grow, and it wanted that growth to come from partners running their own programs instead of asking someone at Fetch to run them. Self-service was the flywheel. There was no enterprise product for a partner to serve themselves in.

A partner who wanted to launch an offer, watch it perform, and adjust the next one had to work across roughly twenty-five separate areas to assemble a single conclusion. Nothing completed the loop. Implementation coordinators held it together by hand, one account at a time.

Partners saw their own numbers when somebody at Fetch built them a readout. Weekly, biweekly, monthly, quarterly, depending on the account. Sales assembled every one of those by hand and delivered it. That was the reporting product.

Design had no team, no artifacts, and no intake. I got my work by sitting with implementation coordinators and product leads, asking what they actually did all day, then tracing which parts of it the data could support.

The dysfunction was not a bad interface. Nobody had designed the operations. Data went wherever the nearest pipeline put it, and there was no model of how a person was supposed to move through any of it. We had tools. We did not have a system.

A system cannot be designed until you know what it actually runs on. So the first work was not design work. It was going after the operational truths sitting in separate heads across product, engineering, account management and implementation, and writing them down in one place where they could be argued with.

That gave us something to divide. Once the truths were on the table, the problem areas separated cleanly, and so did the dependencies underneath them. Three of those decided the order of everything that followed.

Naming those areas correctly did more than scope the work. Each one predicted a workstream, each workstream predicted the design support it would need, and that is how we planned headcount against something real instead of a number somebody felt good about.

The cost was patience. It took a while to actually understand and trace the entirety of an extremely manual offer lifecycle. Once I was able to track down the necessary pieces, we built workflows and subsequent features within the platform to support the major needs.

Four designers and me. I was directly involved in every hiring decision.

I wrote the roles and the levels with the Director of Consumer Design. We built and reviewed the ladder together and agreed on where the bar sat for each level, so a title meant the same thing on both sides of the company.

I split my time between leading, mentorship, and execution the entire way through.

The enterprise design system stayed separate from the consumer one, deliberately. A partner reads our platform to make a decision about money, so it needed density and clarity. The consumer side needed to be fun. Two audiences, two systems, one standard.

The team maintained it themselves. No dedicated systems designer. We worked directly with the front-end platform team so components shipped as code instead of drifting as a Figma library.

What we started changed the consumer side. They rethought and reworked their own system after watching how fast a much smaller team could move. They did not take our components. They took the argument for having a system at all.

I worked with the VP of Product and the CPO as a design leader, and with product and engineering managers as a peer. Every negotiation happened case by case. There was no standing agreement to hide behind.

The loudest argument I had at Fetch was about “real time reporting.”

The position held by leadership was that all partner data should arrive in “real time.” I disagreed, publicly, with people who set the roadmap.

I prototyped it instead of arguing it. The prototype showed two things. What “real time” delivery would actually cost engineering, and that a meaningful share of the data was not actionable the moment it landed. Knowing a number a day earlier does not help if nothing can be done about it until the next cycle.

We landed on a split. Specific patterns live, everything else batched. That decision set the direction for the data platform, and it held. The other path would have cost months of engineering refactoring with no guarantee the incoming data was clean enough to show anyone. The hours were the smaller risk.

I let executives assume too much.

The assumptions came from our newer leadership. They arrived from Pinterest, Google, companies with resourcing we did not have, and they carried priors about how hard things are and how quickly a team should move. The newness of AI in our workflow widened the gap further, in both directions.

I managed sideways well. I managed up quietly. I should have been louder about the reasoning behind the roadmap and clearer about where the company was actually going, because the distance between what leadership expected and what the team understood, landed on my team.

The team is still there. The foundation of the product is still there.

Its shape has changed with what AI made possible since, and the parts that survived are the ones that were never about the interface. Clean data, reducing time, redundancy and errors on entry, and knowing which metrics a partner actually needs. All still in play.