Philo used to be simple. One subscription. One path. Easy to explain. Then things changed. We introduced free entry points, bundles, and different ways to access the product. Good for the business, but it quietly broke the experience.

Upgrade paths got messy. Messaging got inconsistent. Users were bouncing between states without really understanding what they were getting or why they should pay. We didn’t just have a UX problem. We had a system problem.

If you zoomed out, everything looked fine. But when you looked closer, it was fragmented. Upgrade flows depended on where you entered. Messaging changed depending on the surface. Free, trial, and paid states didn’t feel connected. And every new experiment risked stepping on something else.

Worst part, we started seeing cannibalization. Changes meant to drive growth were hurting our core subscription funnel. So the question wasn’t “how do we improve this screen.” It was “how do we stop this from breaking every time we touch it.”

I owned the design side of fixing this. Not just screens. The system behind it. That meant:

• Thinking through every credential state across the lifecycle
• Designing upgrade entry points across web, mobile, and TV
• Working with Growth and PBS to align experiments with business goals
• Running and learning from A B tests
• Making sure whatever we built could scale without constant redesigns

This wasn’t a one feature problem. It was infrastructure.

Before designing anything new, I mapped the entire lifecycle. Free. Trial. Paid. Every state, every transition, every edge case. From there I defined:

• Where upgrade triggers should exist
• When users should see them
• What context they should have before hitting them

This became the foundation for everything else. Instead of reacting to problems, we had a model we could build on.

We ran a lot of experiments. Some of them worked. Some of them didn’t. We tested removing the 10 foot landing page. We tested new upgrade entry points. We tested embedding upgrade education directly into the product instead of relying on external flows. What we learned pretty quickly:

• If you push upgrades too early, you hurt trust
• If you push them too late, you miss conversion
• If you don’t explain free vs paid clearly, nothing works

And most importantly, growth without guardrails will eat your core business.

That changed how we approached everything after.

Instead of shipping one off solutions, I turned what we learned into reusable systems. Two main ones:

Upgrade Value Interstitial
A context aware surface that shows up at key moments and explains the value of upgrading without breaking the flow

Promotional Upgrade Row
A content driven row inside discovery that surfaces premium content in a way that feels natural, not forced

Both were tied to user state, placement, and timing. Not just static components.

The biggest shift was this:

We stopped redesigning surfaces every time the business changed.

Instead, we built a system that could adapt. When Philo introduced new bundles or changed packaging, we didn’t need to start over. The infrastructure handled it. Messaging updated. Entry points adjusted.

Experiments kept running. It gave the team speed without chaos.