We don't miss delivery deadlines because we’re slow; we miss them because we’re optimistic about things we don’t understand.

We spend extra time polishing the tidy parts of our solution because hiding in the known feels safer than confronting the mess.

This is a failure of risk management. Shaping a solution well is, at its core, managing that risk.

Why I Think About Risk Differently

My background is in engineering and insurance risk modelling. In those worlds, you learn quickly that it isn’t the expected outcome that destroys you—it’s the tail risk.

The tail risk is the low-probability, high-impact event that nobody planned for because it seemed unlikely.

In insurance, you don’t model for a normal day. You model for the Black Swan: the 100-year flood that arrives twice in one decade, or the freak disaster that wipes out an entire portfolio overnight.

Here’s what most people miss: software delivery has a remarkably similar risk curve with respect to time.

Your 6-week estimate assumes a “normal distribution” of work. You assume familiar tech, known integrations, and no surprises. That’s the "expected" outcome—and in the real world, it almost never happens.

What actually happens lives in the Tail:

• The third-party API that doesn’t behave like the documentation promised.

• The data migration that uncovers years of inconsistency.

• The “simple” authentication change that touches every service in the stack.

But unlike insurance, software teams have a superpower: we can actually reduce that risk at the source.

You just have to be willing to dig into the mess while you are still shaping the solution—not after you’ve already committed the team to a build cycle.

Subscribe now

The Mental Model: Thinning the Tail

I adapted this chart from Ryan Singer’s book, Shape Up. It’s a mental model that immediately resonated with me because it visualises exactly what we mean by "de-risking”:

Think about it this way:

Every project sits somewhere on a probability distribution of delivery time.

The shape of the two curves tells you everything you need to know about your risk:

1. The Dotted Line (The Safe Bet)

   • This is familiar work. You’ve done it before, the dependencies are known, and the technology is proven.

   • When work sits on the Dotted Line, your distribution is tight and predictable. There is very little distance between your best-case and worst-case scenarios. You estimate 4 weeks, and you ship in 4 weeks. No drama.

   • Most teams assume their work lives here. Most teams are wrong.

2. The Solid Line (The Fat Tailed Bet)

   • Unlike the Dotted Line, the Solid Line has a Fat Tail—this is where the danger lives. The tail represents all the ways a 6-week build can become a 4-month ordeal. The shape of this curve is determined by the unknowns you haven’t addressed yet.

   • What creates a Fat Tail? It’s a taxonomy of rabbit holes:

     • Technical Unknowns: “We’ve never integrated with this system before, but it should be fine.”

     • Design Gaps: “We’ll figure out the edge cases during the build.”

     • Data Assumptions: “The data is probably clean enough.”

     • Dependency Risks: “That team said they’d have the API ready by then.”

     Each of these is a landmine sitting in your plan, waiting for a developer to step on it mid-sprint.

The Red Arrow (The 3x Delay)

• If the Fat Tail of the solid curve represents the possibility of a disaster, the Red Arrow points to a realised outcome in that distribution—a 6-week project that has spiralled into 18 weeks because of a single unaddressed unknown. As a result, a team burns through its entire budget solving a problem that should have been de-risked before the build even started.

• This outcome is expensive in ways that go far beyond the calendar:

  • Morale Damage: Teams lose confidence when they feel “stuck,” and that frustration compounds across sprints.

  • Opportunity Cost: Every week spent in a rabbit hole is a week not spent on the next thing that matters.

  • Trust Erosion: Stakeholders start questioning every estimate, which leads to tighter controls and even worse planning.

→ The Goal of Shaping: Move the proposed solution from the Solid Line to the Dotted Line before the team commits to the build.

Share

Same Project, Two Outcomes

Consider two different approaches to the same project:

Approach A: The Assumption-Led Build

• The Plan: A 6-week build centred around a major third-party integration. The mocks are beautiful, stakeholders are aligned, and the team trusts the provider’s documentation.

• The Trap: Four weeks into the build, a developer makes the first real connection and realises a critical technical requirement—something the entire feature relies on—isn’t actually supported by the vendor.

• The Result: The team is now stuck. They spend weeks in “wait-and-see” mode, at the mercy of someone else’s roadmap. That 6-week project spirals into 18 weeks.

Approach B: The Discovery-Led Build

• The Plan: Faced with the same integration, the lead runs a “Spike”—a time-boxed technical stress test. They quickly scaffold a dirty script to call the API and verify the data before the build starts.

• The Reality: Because they used AI to handle the boilerplate, they find the technical gap within a couple of hours of investigation. Instead of committing to a broken plan, they pivot their approach or change the scope while they still have the flexibility to do so.

• The Result: They set an honest, de-risked 8-week timeline. They ship in 8 weeks.

The difference between these two paths wasn’t better idealistic design. It was the willingness to look at the messy bits while the cost of changing course was still minimal.

How to Actually Thin the Tail

Thinning the tail isn’t a single activity. It’s a discipline applied during shaping that asks fundamentally different questions than most teams are used to.

1. Hunt for the “spiky” bits first: Don’t start with the “happy path”. Start with the parts of the solution that make you uncomfortable—the integration you’ve never done or the unfamiliar data model that feels “probably fine.”

2. Confront the spike: For every major unknown, run a technical stress test. Build the proof that the solution can be built. The goal is the elimination of technical uncertainty.

3. Use AI to accelerate the shaping: Don't solely use AI to churn out more feature code; use it to buy delivery certainty. If you can verify a solution in two hours instead of two days, you’ve removed the excuse for skipping discovery.

4. Involve the skeptics early: Find the expert who always finds the edge cases and get them in the room before you commit. You aren't looking for a pat on the back; you want them to challenge every assumption. Sometimes the best outcome is deciding not to build.

5. Define “done” by risk, not by polish: A shaped solution with rough sketches but zero technical unknowns is 10x more valuable than a high-fidelity mock full of assumptions. I only feel “done” when I can explain exactly how the messiest parts of the problem and solution fit together.

Subscribe now

The Bottom Line

Shaping a solution is the discipline of trying to break your own plan while it’s still cheap to do so. It’s easy to obsess over the happy path solution, but the delivery outcome is decided in the messiest 20% of the build.

If you haven’t solved those bits before the team commits—even if you have a beautiful plan for the predictable parts—you aren’t managing a roadmap; you’re decorating a disaster.

De-risk reality instead of polishing an ideal.

Surface the traps early, and you give your team the one thing every roadmap needs: The confidence to actually ship.

Keep iterating,
— Rohan

→ Connect with me on LinkedIn or reach out via email.

Thanks for reading! Found value in this? Two ways to help:

1. Like, Comment, or Share - Help increase the reach of these ideas.

2. Subscribe for free - Receive my future posts direct to your inbox.

Users misusing your product, building elaborate hacks on top of tools that were never designed for the job, bending features in directions you didn’t expect — these aren’t edge cases. They’re the strongest signal you have about what to build next.

Boris Cherny, the creator of Claude Code at Anthropic and a former principal engineer at Meta, argues on Lenny’s Podcast that latent demand is the single most important principle in product development. He's right.

Subscribe now

1. Latent Demand

Here’s the thing: most product teams operate as if their job is to create demand. They brainstorm new behaviours, design new workflows, and try to convince users to do something they’ve never done before. The implicit assumption is that innovation means invention.

Latent demand flips this entirely. It starts with a simple observation: the demand you’re looking for probably already exists. Users are already trying to do the thing. They’re just doing it badly, inefficiently, or by misusing tools that were never designed for the purpose.

Cherny’s definition is precise — latent demand means identifying what users are already trying to do, often by repurposing existing tools in ways nobody intended, and building a product that makes that existing behaviour frictionless.

This is not the same as user research. Discovery interviews ask users what they want — latent demand ignores what they say and watches what they do. People struggle to describe what they need in the abstract, but they're remarkably honest with their behaviour.

The evidence isn't theoretical. eBay made the classified ad scalable. Craigslist moved bulletin boards online. Airbnb productised informal home-stays that travellers had been arranging for decades. None of them invented demand. All of them built a better surface for behaviour that already existed.

The strongest product signals come from what users are already doing despite your product, not because of it.

2. Hackable Surfaces

So if latent demand is everywhere, how does it reveal itself? Cherny's second principle is the mechanism: build products that are open-ended enough for users to adapt for unintended use cases. He calls them "hackable" products: tools flexible enough that users can repurpose them in ways you never planned.

This is how Cherny approached Claude Code. Developers were already trying to use AI models as autonomous agents — hacking together scripts, chaining prompts, building crude pipelines to make LLMs do real engineering work. The behaviour existed. Claude Code didn't create the demand, it gave that behaviour a proper surface.

The pattern didn’t stop with developers. As Claude moved into broader use, Anthropic noticed users were already trying to get the model to create charts, diagrams, and interactive visualisations within conversations — bending a text interface toward something visual. Custom visuals in chat formalised that behaviour into a feature. Same principle, different surface.

Think about the products that have survived every wave of disruption. Spreadsheets never assumed they knew what you wanted to do with them — they don’t have an opinion about whether you’re building a financial model or running a small business from a single tab. That radical openness is what makes them the ultimate latent demand detector, because every creative misuse is a product waiting to be built.

Leave deliberate openness at the edges — the kind of flexibility that lets a power user surprise you with a use case you never anticipated. Those surprises are your richest source of latent demand.

The best products create a surface where users discover problems you never anticipated.

3. The Observation Gap

If latent demand is sitting in plain sight, why do most teams miss it?

The answer is structural, not intellectual. Every PM has heard the advice to “observe your users.” The problem is that most teams treat observation as a phase — something you do during discovery or shaping and then move on. Latent demand doesn't work on a schedule. It emerges continuously, in the gap between what you built and what users actually do with it after launch. And the signals live in places that most product teams never look.

Think about where latent demand hides in practice. It’s in the support ticket where a customer describes an elaborate workaround they’ve built on top of your product. It’s in the operations team’s internal tools, the ones they hacked together because the product doesn’t quite do what they need. It’s in the “creative misuse” that a power user demonstrates on a call, the thing that makes you say “wait, you’re using it for that?”

These signals are abundant, but they live in the wrong meetings. Support teams see them daily but report them as bugs or feature requests rather than strategic signals. Operations teams build workarounds and never surface them to product because nobody asked. The data exists. It just never flows back to where decisions get made.

Cherny’s process makes this explicit: observe how users interact with what exists, find the latent need buried in their behaviour, and build for that specific behaviour. The key word is observe — not imagine, not hypothesise, not brainstorm. Observe.

The teams closest to your users are seeing latent demand every day. They’re just not calling it that.

4. Examples: Facebook Marketplace / Apple’s App Store

By 2016, Facebook Groups had become an unexpected commercial hub. More than 450 million people were visiting buy and sell groups each month — people posting photos of furniture, electronics, clothing, with prices in the descriptions and “DM me” in the comments. No listing format, no payment infrastructure, no search. Users had hacked a marketplace out of social infrastructure using nothing but posts and direct messages.

Facebook observed this behaviour that already existed and gave it a proper surface. Marketplace launched in 2016 with a simple premise: take the commerce that was already happening at scale and build a new product around it — structured listings, local search, category filters. By 2020, the Marketplace product had reached 800 million monthly active users.

The iPhone tells a remarkably similar story. When it launched in 2007, Steve Jobs was adamant: no third-party apps. The iPhone would run Apple’s software only. Developers were told to build web apps instead.

Users disagreed. Within months, a jailbreaking community emerged — developers hacking past Apple’s restrictions to install their own software. First utilities, then games, then productivity tools. The behaviour was unmistakable: people wanted to put their own software on this device, and they were willing to work around Apple’s explicit restrictions to do it.

Jobs tried to resist the demand, but when your users are literally hacking your product to do the thing you told them they couldn’t, the signal is hard to ignore. Apple launched the App Store in July 2008, and within its first weekend, 10 million apps were downloaded. Nine months later, that number hit one billion. Suddenly your phone was a tape measure, a guitar tuner, a way to identify any song playing in a bar, a fake pint of beer you could pretend to drink. The app ecosystem, not the hardware alone, is what made the iPhone dominant.

Two products, two platforms. Both succeeded by building a surface for something people were already doing.

How to Apply This

1. Notice what users and teams are building around you:
Pay attention to the workarounds. The tools your operations team hacked together. The creative ways users are bending your product to do something it wasn't designed for. These aren't failures of the product — they're signals about what to build next.

2. Design with open edges:
When scoping a feature, notice where you're constraining users to predefined paths versus where you're leaving room for them to do something unexpected. The more closed the feature, the less it can teach you. The gap between the path you designed and the path users choose is where latent demand reveals itself.

3. Watch how different cohorts use the same product:
A power user and a first-time user will bend your product in completely different directions. Pick two or three distinct segments, shadow them, and map how your product actually fits into their workflow. Not how you designed it to fit. The gaps between cohorts often reveal latent demand that a single-persona view would miss.

4. Make it a standing signal, not a one-off exercise:
Latent demand signals shouldn’t be a quarterly research project. Build a channel where support, operations, and customer success can surface patterns continuously, and make those patterns a standing item in your product review. The signals are already there. You just need to make sure they reach the people making product decisions

Subscribe now

The Bottom Line

The best product decisions you'll make this year won't come from a brainstorm. They'll come from something a user is already doing, with tools that were never designed for the purpose, that you haven't noticed yet.

Keep iterating,
— Rohan

→ Connect with me on LinkedIn or reach out via email.

Thanks for reading! Found value in this? Two ways to help:

1. Like, Comment, or Share - Help increase the reach of these ideas.

2. Subscribe for free - Receive my future posts direct to your inbox.

I still have my first MacBook—a chunky 2008 MacBook Pro with visible screws, a swappable battery, and a switch-tab that welcomed you inside. I’ve kept it all these years—not just out of nostalgia, but because it reminds me what technology used to feel like.

One winter break, back in school, I used Christmas money and a YouTube tutorial to upgrade the RAM—from 4GB to 8GB. I still remember the quiet thrill of booting it up and seeing the system recognize the change. It wasn’t just faster—it felt like mine in a way modern devices rarely do.

That feeling—that rush of I did this—is something an entire generation might never experience.

Over time, something quietly shifted. Laptops became sealed shut. Phones arrived pre-assembled and tamper-resistant. Game makers began treating modifications as security threats rather than creative expression.

The message was clear: We built it. You use it. That’s the deal.

So began what I think of as the sealed-box era—a time when products were designed not just to discourage tinkering, but to punish it:

• Warranties voided the moment you opened the case.

• Components soldered to prevent replacement.

• Software locked with cryptographic signatures.

• Patches deployed to block “unauthorized” changes.

• Legal threats against those who reverse-engineered systems.

Tinkering didn’t just become difficult—it became forbidden.

To be fair, the shift brought benefits. Standardization improved reliability. Sealed systems enhanced security. Polished experiences reduced friction.

But something else was lost.

We stopped being users of tools—and became consumers of products.
Curiosity gave way to convenience. Ownership faded into obedience.

And with it, a quiet but powerful way of learning disappeared too.

The Hidden Cost of Perfect Products

What disappeared with tinkering wasn’t just the ability to modify our tools—it was a way of learning, a way of thinking, and a way of relating to technology.

When products became perfect black boxes, we lost:

• Direct feedback loops – The immediate cause-and-effect experience when something works—or breaks—because of your actions.

• True ownership – The deep connection that comes from understanding and shaping your tools from the inside out.

• Learning through failure – The hands-on education that happens when things go wrong and you have to figure out why.

• Progressive mastery – The journey from small tweaks to full control, where confidence builds through each success and mistake.

I felt this shift in my own life. In my early years, I disassembled anything I could, tweaked operating system files, and wrote simple scripts—driven by curiosity, not instruction. But as technology moved into the sealed-box era, I found myself simply selecting products rather than shaping them.

For a while, I thought this was just the cost of progress—a tradeoff of freedom for polish, exploration for efficiency.

Thankfully, I was wrong.

Subscribe now

From “What If?” to “Ship It”

For many of us, the instinct to build started early.

I grew up on Lego and Minecraft. I didn’t think of it as learning at the time—but that’s exactly what it was. Experimenting, breaking things, fixing them again. They taught me modularity, systems thinking, and the joy of solving problems by building from scratch.

Ask a room full of engineers, designers, or product folks what sparked their curiosity, and these tools come up again and again. They didn’t just offer creative freedom—they gave us a way to understand complexity by constructing it ourselves.

But adulthood reshapes that instinct.

Deadlines replace curiosity. Deliverables take priority over exploration. There’s less time to think, and more pressure to ship. We stop building for the sake of understanding, and start reaching for whatever tool gets the job done fastest.

No-code platforms briefly reopened that creative door. Tools like Zapier, Webflow, and Notion let non-technical people assemble real things again. But the freedom came with guardrails. You could connect and configure—but only within the logic someone else defined. It was more like wiring together sealed modules than building a system from the inside out.

Unlike Lego or Minecraft—where the parts invite experimentation and reveal how systems work—no-code tools often abstract the system away. You're assembling workflows, not shaping foundations. You’re building with what you’re given, not imagining what else could be made.

It felt like building. But it wasn’t quite tinkering.

That deeper instinct—the what happens if I take this apart? mentality—remained out of reach.

Until now.

The AI-Powered Renaissance

We're witnessing something remarkable: AI is reviving the spirit of tinkering—not by removing constraints, but by reshaping our relationship with them.

Tinkering has always thrived under certain conditions:

• Low cost of experimentation – You can try things without significant investment.

• Rapid feedback – You quickly learn what works and what doesn’t.

• Progressive disclosure – Complexity reveals itself gradually, as you’re ready for it.

• Personalized paths – You follow your own curiosity, not a prescribed curriculum.

AI-assisted creation delivers all of these—but in an entirely new form.

The New Workshop

Not long ago, modifying code without programming knowledge meant hours of tutorials, documentation, and trial-and-error—just to get a basic script working.

Today, someone can ask:

• "Can you help me create a tool that tracks the books I read and recommends similar titles?"

• "I need to analyze these spreadsheets for patterns, but I don't know where to start."

• "How would I build a simple app that lets my friends vote on where to go for dinner?"

These kinds of requests—once reserved for developers—now lead to real results in minutes. AI takes care of the technical scaffolding while you stay focused on the problem you’re solving.

This isn’t just “easier coding.” It’s a return to learning through building—with fewer barriers, faster feedback, and more room to explore.

It’s not about skipping the fundamentals. It’s about accessing them differently—through hands-on iteration instead of passive theory. The kind of learning that sticks because it’s rooted in your own curiosity.

When the Cost of Failure Approaches Zero

Traditional tinkering came with real risks:

• Physical materials that couldn’t easily be reset.

• Time-consuming research into technical requirements.

• The possibility of breaking expensive hardware.

• The need to grasp foundational concepts before anything useful could be built.

AI dramatically lowers those barriers:

• Digital materials that can be endlessly modified or rolled back.

• Contextual explanations delivered when you need them.

• Guardrails that prevent catastrophic errors.

• The ability to build useful tools without mastering every underlying detail before you begin.

If something doesn’t work, there’s no punishing three-day debugging session—just a quick, conversational loop:

“That didn’t quite work. Can you explain what happened and how we might approach it differently?”

That’s the new debugging process. It's iterative, forgiving, and far less intimidating.

The result? You learn by doing—by solving problems, not studying abstractions.

I’ve read countless books on sales—but I still don’t feel confident selling. The skill didn’t click because I hadn’t practiced it. The same goes for building with AI: understanding doesn’t emerge from theory alone. It comes from making, breaking, and refining things in context.

When the cost of experimentation drops to nearly zero, so does the fear that stops people from trying in the first place.

From Consumers to Creators

This shift matters far beyond hobbyists and technologists.

For decades, we’ve been trained to be careful consumers of technology—comparing features, reading reviews, choosing the best option from a limited menu. But rarely creating our own solutions.

The result? Most problems only get solved when they align with market demand—when enough people share the same need to justify a product. If your problem doesn’t fit the mould, you’re out of luck.

But what about all the specific, everyday problems that fall between the cracks?

• A recipe app that lets you filter by techniques you’re trying to master—not just ingredients

• A research tool that organizes sources the way you think, not how citation managers assume

• A client tracker designed for a solo consultant—not a sales team of fifty

• A family schedule that balances part-time jobs, school pickups, and split custody—not a standard 9–5 calendar

These kinds of tools are entirely possible. But they’ve never been practical to build—because building software used to require either technical expertise or a business case big enough to justify a team.

AI changes that. It lowers the barrier to creating tailored solutions—not just for others, but for yourself.

It turns “this would be useful, but no one’s built it” into “I can try building it right now.”

The Long Tail of Product Needs

Traditional product development operated under a simple constraint: building things was expensive. That meant companies had to serve large markets to make it worth the investment.

They focused on the “head” of the distribution curve—common problems with mass appeal. But the “long tail” of specific, personal, or niche needs remained largely untouched.

The result? Tools that worked well enough for most people, but perfectly for almost no one.

But when creation costs drop—when a single person can build something useful in a weekend—the economics flip. Serving smaller segments further along the curve becomes not just viable, but valuable.

A food blogger can create their own recipe organizer. A freelancer can build a CRM that actually fits how they work. A teacher can develop tools that match their classroom style—not district-wide policy.

The long tail becomes a frontier—not of leftovers, but of unserved opportunity.

This may be the most important shift in product development since the rise of the web: the ability to build specific solutions at personal scale.

Share

Domain Expertise, Directly Applied

One of the most transformative aspects of this shift is how it changes who gets to shape technology.

Traditionally, domain experts—doctors, teachers, researchers, scientists—had to funnel their ideas through a long chain: product managers, designers, engineers. Each handoff introduced friction. Each translation risked losing nuance.

It’s why clinicians often find medical software clunky. Why educators struggle to bend learning tools to their methods. Why finance teams end up hacking spreadsheets instead of using the expensive tools built for them.

The problem wasn’t just poor design. It was separation—between the people with the problem and the people with the power to build.

That’s now changing.

When a climate scientist can create a prototype to visualize localized risk, or a coach can sketch and iterate on a progress-tracking system for their clients, something important happens: the domain expertise doesn’t have to be translated. It can be expressed directly—shaped into something usable without needing to justify a business case or write production-grade code.

This doesn’t mean everyone becomes a developer. But it does mean that the ability to think in tools—to explore, iterate, and shape software around specific needs—is becoming a serious advantage.

The most meaningful tools going forward won’t just be built for experts. They’ll be built with them—by people who combine deep domain insight with just enough creative leverage to start building.

Preserving the Tinkering Spirit

As this transformation unfolds, we need to be intentional about preserving what made tinkering valuable in the first place:

• Stay curious about how things work – Even as AI makes building easier, understanding the mechanics still matters. The best tinkerers ask not just "Can you make this?" but "How does it work?"

• Treat failure as feedback – When something breaks or behaves unexpectedly, use it. The best breakthroughs often come from what didn’t work the first time.

• Share what you build – Tinkering thrives in public. When you share both the outcome and the process, others learn—and often improve on it.

• Push past artificial constraints – Question the limitations imposed by platforms, policies, or defaults. Great tinkerers push boundaries—not recklessly, but thoughtfully.

• Start with something real – The most satisfying projects come from real needs. Begin with what frustrates you, what doesn’t quite fit, what could be better.

Share

The Pendulum Swings Back

Perhaps what we’re witnessing is technology coming full circle.

We moved from open systems that invited experimentation, to closed ecosystems that optimized for control. Now we’re entering a new phase—where AI brings the reliability of modern tools together with the creative freedom of the tinkering era.

The technical barriers that once limited creation to specialists are falling. In their place, a more democratic relationship with technology is emerging—one where anyone with a problem to solve and a question to ask can start building.

The spirit that drove us to first pick up that screwdriver—that pure curiosity about how things work and how they might work differently—hasn't disappeared. It was just waiting for new tools to make it accessible again.

We’re not just consumers anymore. We’re back to being builders.

Welcome to the tinkerer's renaissance.

Keep iterating,
—Rohan

→ Connect with me on LinkedIn or reach out via email.

→ Check out Product Artistry Games.

→ Want to go deeper? I'm opening just 5 slots for 30-minute 1:1 calls with paid subscribers this month. We'll tackle your specific product challenges, refine your ideas, or explore your creative direction. Upgrade now and I'll send booking details directly to your inbox.

Thanks for reading! If you’ve found this post valuable, here’s how you can show your support:

1. Like and Share: Spread these ideas to others who they may resonate with.

2. Become a Paid Subscriber: Help support my work and mission.

Subscribe now

Still here? I’d appreciate you taking a second to answer this quick poll for feedback:

What should have been a moment of celebration quickly turned into panic.

The surge brought an incredible wave of feedback—but I had no structured way to capture, analyze, or act on it beyond this moment. My fun experiment had suddenly become something real, with real expectations. And I wasn’t ready.

Like many creators, I had focused entirely on building the core experience, assuming I’d figure out feedback later. But when traction hit, my biggest regret wasn’t a lack of feedback—it was not having a system to make sense of it when it mattered most.

I wasn’t alone in this. Again and again, I’ve seen the same pattern:

The difference between products that thrive and those that fade often comes down to how well their creators capture and respond to feedback.

The biggest lesson I learned?

Your feedback system can’t be static—or an afterthought.

It needs to be baked into your product from the start—and ready to evolve.

At every stage of growth, you’ll face different questions that require different feedback approaches:

• Validation → Will anyone use this at all?

• Refinement → How can we improve the experience?

• Direction → What should we build next?

• Monetization → What would people pay for?

• Growth → Would users recommend this to others?

Yet most MVPs rely on a single feedback method—if any—leading to either overwhelming complexity or oversimplified insights. Neither works.

Here’s how my approach to feedback evolved as my product grew—and why yours should too.

How My Feedback System Evolved

After Dark Patterns Detective gained traction, what started as a single-page app expanded into a broader platform: Product Artistry Games. This shift gave me more surface area for feedback touchpoints, allowing me to experiment with different methods of gathering user insights.

Stage 1: Basic Completion Tracking (Validation Stage)

Key Question: Is this engaging enough for people to finish?

At this stage, my only feedback mechanisms were:

• A newsletter signup after game completion, signaling deeper interest.

• A “Report a Bug” / “Get in Touch” button in the footer, which simply opened an email form.

The newsletter signups were an early signal of positive engagement, confirming that some players wanted to stay connected. However, beyond that, my system had gaps. The footer buttons were too high-friction, and sending an email was too much effort for casual feedback.

Strategic Touchpoint: Game completion page

Result: While the newsletter signups provided a proxy for interest, the most valuable insights during the traffic spike didn’t come from my system—they came from the Hacker News discussion.

Insight: When your product gets attention, users will talk about it where they already are—meet them there.

Stage 2: External Platform Feedback (Refinement Stage)

Key Question: How can I improve the experience and clarity of the game?

Hacker News had given me a firehose of feedback and surfaced critical feedback on game design and usability, shaping my first round of refinements—but it wasn’t scalable.

I needed a way to:

• Capture structured feedback inside the game

• Identify common pain points beyond early adopters

• Understand which improvements would have the most impact

While platform discussions (Hacker News, Mastodon, LinkedIn) continued to be valuable, they weren’t enough. I needed a system for engaged players, not just one-time visitors.

Strategic Touchpoint: Embedded feedback mechanisms requirement

Insight: External platform feedback is great for identifying early refinements, but it won’t help answer strategic product decisions.

This realization led me to expand Product Artistry Games, giving me more room to test built-in feedback loops, as we’ll see in the next stages.

Stage 3: Direction Validation (Direction Stage)

Key Question: Do people want more—and if so, what topics specifically?

With Product Artistry Games, I had a dedicated space for interactive learning games. This gave me a structured environment to test more scalable feedback mechanisms.

I introduced a low-friction voting system on the main games page:

• Simple, icon-driven choices

• Single-click voting (no signup required)

• Instant visual confirmation

Strategic Touchpoint: Main games directory page

Result: This mechanism generated nearly 100 votes, revealing two clear favorites in a classic Pareto distribution (80/20 rule).

Meanwhile, the higher-friction “Choose Other” dropdown saw little engagement—reinforcing the importance of keeping feedback simple.

Insight: The easier you make it to give feedback, the more responses you’ll get.

This insight became the foundation for how I would later test monetization options.

Stage 4: Value Proposition Exploration (Monetization Stage)

Key Question: What resources would people find valuable and potentially pay for?

Building on the success of the game voting system, I introduced a paid resources interest poll on my home page.

Strategic Touchpoint: Home page (lower section)

Result: Unlike the games page, this poll received almost no engagement.

Why?

• Low visibility – The poll was buried too far down the page

• Low urgency – Users weren’t thinking about paid content yet

• Too broad – The options weren’t specific enough

• Casual Visitors vs. Core Audience – Most users were just exploring, not actively looking for solutions

While this confirmed that some interest existed, it wasn’t actionable. I’ve since removed this poll and plan to reintroduce it in a more targeted, visible touchpoint.

Insight: Just because a feedback method works in one context doesn’t mean it will work everywhere.

Stage 5: Referral and Satisfaction Measurement (Growth Stage)

Key Question: Would people recommend this game to others?

With a growing player base, I needed a scalable way to measure user satisfaction. Before launching my second game, I introduced a Net Promoter Score (NPS) survey on the completion screen:

• Standard 0-10 rating scale

• Optional open-ended feedback field

• Reusable across future games

Strategic Touchpoint: Game completion screen

Result: The initial NPS for Dark Patterns Detective was 65+, indicating strong user satisfaction and providing a benchmark for future products.

Unlike unstructured feedback, this approach let me track trends over time and compare satisfaction levels across different releases.

Insight: Pairing a lightweight metric with optional open-ended feedback struck the right balance. The structured rating ensured a high response rate, while the optional text field let engaged users share deeper insights.

Share

A Simple Approach to Effective Feedback

Through my journey with Product Artistry Games, I’ve distilled three core principles for designing effective feedback systems. The key is ensuring that feedback is:

• Targeted – Focused on the right question at the right time.

• Easy to Give – Low-friction, encouraging higher participation.

• Captured at the Right Moments – Embedded naturally into the user experience.

1. Start with Your Most Important Question

Every stage of growth presents a different uncertainty. Instead of collecting broad, unfocused feedback, pinpoint the single question that, once answered, will clarify your next steps.

Examples:

• Early validation: Will people finish this game?

• After going viral: What topic should I tackle next?

• With an established audience: Will users pay for premium content?

Without a clear focus, feedback becomes scattered and ineffective.

Action Step: Before adding any feedback mechanism, ask:
"What is the one insight I need most right now?"
Then design your system around that.

2. Keep Feedback Mechanisms Simple

The more effort it takes to provide feedback, the fewer responses you’ll get. Simpler methods increase participation, while complex forms discourage engagement.

Friction Spectrum:

• One-click feedback → Baseline participation

• One-click with optional follow-up → Captures deeper insights while keeping participation high

• Short forms (2-3 fields) → Requires effort, leading to fewer responses

• Longer forms → Highest friction, minimal engagement

Even small increases in effort drastically reduce participation. However, bundling an optional follow-up with a low-friction action—like adding a comment field to an NPS survey—can capture richer insights without deterring users.

Action Step: For every feedback mechanism, ask:
"What’s the absolute simplest way to collect this insight?"
Then strip away unnecessary steps—or bundle follow-ups into low-friction interactions.

3. Capture Feedback at the Right Moment

When and where you ask for feedback is just as important as how you ask.

Your feedback prompts should:

• Appear at moments of peak engagement

• Align naturally with what users are already thinking about

• Minimize disruption to the user’s flow

Examples of well-timed feedback:

• Game completion pages → Great for gathering insights when users are most engaged

• Game directories → Work well for quick directional voting

• Monetization surveys → Must be highly visible and shown when users are already considering purchases

Poorly timed or misplaced feedback requests lower response rates and reduce data quality.

Action Step: Map your user journey and place feedback prompts strategically at high-engagement moments that align with user intent.

Subscribe now

The Feedback Funnel Formula

As my product evolved, I started thinking about feedback as a simple equation:

Each factor represents a lever you can influence:

• Traffic → The number of visitors coming to your product. Essential but often unpredictable, especially for indie projects. This is the widest part of the funnel.

• Engagement Rate → The proportion of visitors who are genuinely interested and interacting meaningfully. Driven by clear value proposition and audience-product fit. This is the middle of the funnel.

• Submission Rate → The percentage of engaged users who complete feedback requests. This is where friction plays the biggest role. The narrowest part of the funnel, and where thoughtful feedback design makes the biggest difference.

By improving these three levers, you can increase both the quality and quantity of feedback, leading to better decisions and a more audience-driven product.

Putting This Into Practice

To show how different feedback approaches affect what you learn, here’s a simple comparison of high-friction vs. low-friction systems.

Example: High vs. Low Friction Feedback Systems

Imagine a product with 1,000 monthly visitors:

1. Traffic → 1,000 visitors enter the top of the funnel.

2. Engagement → 30% are genuinely engaged → 300 users.

3. Submission Rate:

   • A multi-field form (high friction) might get a 5% submission rate → 15 responses.

   • A single-click mechanism (low friction) might get a 50% submission rate → 150 responses.

The difference between 15 and 150 responses is massive—it separates anecdotal data from clear, actionable patterns.

• With only 15 responses, it’s hard to detect meaningful trends.

• At 150 responses, patterns emerge, making it far easier to make evidence-driven decisions.

Engineering My Feedback Funnel

This mental model led me to systematically improve each stage of my feedback funnel:

• For engagement → Placed feedback mechanisms at high-engagement moments and context-appropriate touchpoints.

• For submission → Reduced friction to maximize response rates.

• For overall volume → Optimized for participation and clarity, ensuring that even with lower traffic periods, I still received meaningful insights.

  ---

Why This Approach Works

By making it easier for users to share their preferences, I build features they actually want—leading to higher engagement and better products.

Instead of guessing what might resonate, I now have direct channels to understand what my audience values.

The feedback funnel isn’t just a measurement tool—it’s a framework for prioritizing improvements at each stage of product growth.

Share

Conclusion

Effective product development isn’t about answering every possible question at once—it’s about identifying the specific uncertainty holding you back and designing the simplest feedback mechanism to resolve it.

A static feedback system won’t keep up with a growing product. As your audience evolves, your approach to gathering insights must evolve with it.

Don’t wait until users arrive—build adaptive, lightweight feedback loops from day one.

Speed alone isn’t a competitive advantage anymore. Learning fast is. And that starts with asking the right questions, in the right places, at the right times.

Keep iterating,
—Rohan

→ Connect with me on LinkedIn.

Thanks for reading! If you’ve found this post valuable, here’s how you can show your support:

1. Like and Share: Spread these ideas to others who they may resonate with.

2. Become a Paid Subscriber: Help support my work and mission.

Subscribe now

P.S. I have two exciting announcements since my last post:

🎮 New Game: Notification Psychology Lab – Explore the psychology behind effective notifications through interactive play. Play Free Now →

📚 New Resource: Dark Patterns Handbook – Designed as a companion to my game, Dark Patterns Detective, this comprehensive Notion handbook takes those concepts deeper with practical frameworks and implementation guides. Free bonus for Paid Subscribers!

Still here? I’d appreciate you taking a second to answer this quick poll for feedback:

Last week, my parents opened Microsoft Word, expecting the familiar blank page—the starting point for countless letters, documents, and stories.

Instead, they were met with a prompt:

"Let Copilot help you draft."

No explanation, no context—just an invitation for the software to assist them in writing before they had even gathered their thoughts.

"What's Copilot?" they asked, confused.

A word processor’s job description is simple: help people process words. Not generate them. Not predict them. Not replace them. Process them.

Yet here was Word—software that had faithfully served many writers for decades—eager to insert it’s shiny new capability before my parents had even begun to write a word.

This isn’t just feature creep—it’s a crisis of product identity. In the rush to integrate AI, we’re undermining the very purpose of the tools we create. We’re not enhancing products—we’re fundamentally changing them.

The blank page—a timeless and universal symbol of possibility—is no longer blank. The space where creativity begins now imposes algorithmic influence before fingers even touch the keyboard.

And it’s not just Word. Across the industry, AI integrations are breaking fundamental design principles, shifting tools away from their original purpose, and alienating users.

As the legendary Don Norman wrote:

"Good design is actually a lot harder to notice than poor design in part because good designs fit our needs so well that the design is invisible, serving us without drawing attention to itself."

AI should be invisible when it needs to be. Instead, it's taking center stage—whether we asked for it or not.

The Promise of Purpose

Great products keep their promises. They create a consistent, predictable experience that users trust.

A word processor promises to help you refine your thoughts, just as a notebook promises to capture them. Every tool establishes an unspoken contract with the user—a clear understanding of how it will serve them, and just as importantly, when it will step aside.

But when a product breaks that promise, it forces users into an experience they never agreed to. Generative AI in a word processor doesn’t just add functionality—it reshapes the entire interaction. The product itself changes, and so does the way users engage with it.

What was once a blank page—a space for thought, creativity, and intent—now demands the user’s attention before they’ve even begun. Instead of writing, they’re prompted to think about prompts. Instead of forming their own ideas, they’re nudged toward curating the means for the best probabilistic guess of what they might really want to say.

The experience shifts from authorship to curation, from creation to selection—where the tool inserts itself before the user has even gathered their thoughts.

This isn’t just an evolution of software—it’s a shift in control.

• A note-taking app promises to capture your ideas as they come.

• A camera app promises to take a photo when you press the shutter.

• A writing tool promises to help you write true to your vision.

But when AI assumes control—suggesting words before they’re thought, altering images before they’re reviewed, surfacing “smart” notes before they’re written—it disrupts the natural flow of user interaction. It redefines who is in charge.

When products break this contract, they don’t just frustrate users—they undermine trust and autonomy.

A tool that once felt intuitive and dependable now feels unpredictable, intrusive, and misaligned with the user’s intent. Instead of enabling creativity, it competes for control.

The more a tool asserts itself, the less it feels like something you use—and the more it feels like something you have to manage.

Once users lose confidence in how a product behaves, they stop trusting it. And when they stop trusting it, they stop using it.

Great design will ensure AI supports users—rather than steering them.

Share

Generative AI Isn't New—But the Hype Is

The challenge of integrating generative AI isn’t new. What’s new is how aggressively it’s being forced into every product.

Fifteen years ago, Adobe introduced Content-Aware Fill to Photoshop CS5. Select an object, press a button, and Photoshop would seamlessly reconstruct the background as if the object had never been there. It felt like magic.

It was, fundamentally, an early form of productized generative AI—yet it never disrupted the user’s workflow.

Adobe marketed and implemented Content-Aware Fill as a means to facilitate the user’s vision—not replace it. The adjustment was made by the user, not for them.

• Photoshop didn’t assume any object needed to be filled.

• It didn’t interrupt your work with unsolicited suggestions.

• It was there when needed—invisible when not.

Now compare that to today’s AI integrations:

• Before you type a word, AI is ready to write for you.

• Before you review your photos, AI is stitching them into slideshows.

• Before you select a canvas size, AI is offering suggestions—shaping the work before you’ve even begun.

These tools no longer wait for user intent—they rush to fill every blank space.

When Photoshop introduced Content-Aware Fill, it was designed to extend user capabilities on demand—not dictate the workflow.

But today’s AI features lack that restraint. Instead of supporting user intent, they preempt it.

The contrast is clear:

• Content-Aware Fill succeeded because it remained an option, not an imposition.

• Today’s AI integrations disrupt more than they improve—demanding attention, assuming problems that don’t exist, and compromising the core experience of the tools they inhabit.

The issue isn’t AI itself but the failure to design it in service of the user and respecting their agency.

Subscribe now

A Question of Trust

Trust isn’t built on probability. It’s built on intentional design.

When AI is embedded into core product experiences without oversight, we’re not just outsourcing design decisions and value delivery to probability models—we’re forcing users to be our quality assurance team.

Instead of delivering reliable, well-crafted tools, we’re asking users to navigate unpredictable AI-generated outputs, hoping the system gets it right. And when it doesn’t? The burden is on them to detect, correct, and adapt.

That erosion of trust is why many users, myself included, are moving away from once-reliable tools that have succumbed to this.

AI is undoubtedly a powerful tool for building the next generation of products—but right now for many products, it will be better suited for design and development than for driving the experience itself.

We have real problems to solve—bugs to fix, backlogs to clear, workflows to improve. AI can help us work faster, refine ideas, and validate solutions—but the responsibility still lies with us as makers.

When AI is used to improve development:

• Designers and engineers retain control over the final solution.

• Every interaction is validated before reaching the user.

• The product remains predictable and reliable.

• Trust is built through consistency.

When AI becomes the product experience itself:

• Control is surrendered to probability.

• Behaviors become inconsistent and unpredictable.

• Users must validate and correct AI-generated outputs.

• Trust is replaced with hesitation.

The distinction is clear: In most cases, AI is best used to accelerate progress toward meaningful development, not to serve as the sole arbiter of a product’s features, value, or purpose.

A tool that forgets its purpose fails the people who rely on it. When a tool works well, it fades into the background, allowing users to focus on their work and enter flow. But when AI takes over core interactions, users are forced into a constant cycle of evaluation and doubt:

• Is this response correct?

• Should I regenerate it?

• Can I trust this suggestion?

These aren’t minor inconveniences—they’re cognitive burdens that pull users away from their actual tasks. It’s the digital equivalent of a poorly designed door—where people stop, hesitate, and second-guess, unsure whether to push or pull.

When we replace intentional design with probabilistic AI features, we’re not innovating. We’re abdicating our responsibility as designers.

Share

Choosing a Better Path

As builders and designers, we face a choice.

Before integrating AI, we should ask:

• Is AI helping us build a better product, or are we using it to avoid making real design choices?

• Is it reinforcing our product’s purpose, or is it steering it somewhere different?

• Is it strengthening user trust, or slowly eroding it?

• Is it making our product more reliable, or more unpredictable?

Great products are built through deliberate, thoughtful decisions that put users’ needs first.

AI can help us work smarter, move faster, and refine our craft—but it should never be a replacement for clear intent, accountability, and the discipline of good design.

The best products last because they serve a purpose, not a trend. In the race to innovate, we need to ask ourselves:

Are we designing with intent, or offloading the burden to AI and our users?

That choice defines everything.

Keep iterating and stay purposeful,
—Rohan

→ Connect with me on LinkedIn. Interested in working together? Here’s how I can help.

Thanks for reading! If you’ve found value in these ideas, there are three simple ways to share your support:

1. Like and Share: Spread these ideas to others who they may resonate with.

2. Subscribe for Free: Get future posts delivered straight to your inbox.

3. Become a Paid Subscriber: Support my work (and caffeine addiction).

Subscribe now

Still here? I’d appreciate you taking a second to answer this quick poll for feedback:

What if we could make manipulative design patterns not just visible, but tangible in a safe environment?

As a product manager, I’d spent a lot of time thinking about how design influences behavior—for better or worse. But explaining dark patterns to others, especially those outside the tech bubble, always felt abstract and theoretical. I wanted to change that.

The idea was simple: a minigame that doesn’t just reveal dark patterns but makes people experience them. It wasn’t meant to be a polished product or a portfolio piece. This was an experiment—a way to learn frontend web development and test how design could teach through interaction. Every decision felt like a question waiting to be answered.

At first, I kept the scope small. No flashy features, no extras—just the core mechanics to test if the idea resonated. I wanted the project to feel intentional, even in its simplicity.

Could the game communicate the nuances of manipulative design patterns effectively without overwhelming users? That was the challenge I set out to solve.

What began as a quiet learning project slowly gained traction. Encouraged by early feedback, I shared it more widely with newfound confidence of its value, thinking:

If even one person learns to spot these patterns, it’ll be worth it.

Then, on Friday, everything changed.

The game hit the front page of Hacker News, and suddenly, my little experiment was being tested live by thousands of users across the globe. What followed was equal parts thrilling and humbling—a crash course in building, iterating, and learning in public.

The First Version: Intentionally Incomplete

When you're building solo, every feature is a highly consequential choice. Each new component isn’t just more code—it’s added complexity to manage with tight resources. From experience, I knew how easily scope creep could derail projects, so I relied on this principle to guide my design and development decisions.

The navigation was one-way only: no back button, no lesson jumping. The UI was stark, with minimal styling to avoid distractions. Success messages automatically advanced after each correct answer. These limitations weren’t oversights—they were deliberate choices tied to specific hypotheses:

• One-way navigation: Would linear progression result in actual completion, or would users become frustrated and disengage?

• Minimal UI: Could lessons stay clear and engaging without unnecessary design flourishes?

• Simple feedback: Would straightforward success messages motivate users to finish all 10 lessons, even with the imperfections of this version?

Measuring Success

To measure success, I used a simple to implement yet effective approach: users had to complete every lesson to reach the end, where I embedded a newsletter signup. If I received any signups, it meant the game was being completed—and that people were interested in more.

Validation came unexpectedly. After connecting with over a shared appreciation for building with Claude Artifacts on Substack Notes, he featured the game in his newsletter Department of Product and it was also picked up by the TLDR Design newsletter. Nearly 2,000 users tried it in a single day, with overwhelmingly positive feedback from the design and UX communities.

Engagement and Growth

What stood out wasn’t just the praise—it was how people engaged with the game. Users weren’t just completing the lessons; they were sharing it through word of mouth and social media. Every share reinforced the value users found in the game, even in its imperfect form.

This validation gave me the confidence to iterate thoughtfully. For example:

• Mobile users struggled with certain interactions, prompting me to focus on responsive design improvements.

• Each update prioritized amplifying what worked while addressing what didn’t.

Within days, the game began to evolve from a personal experiment into a legitimate teaching tool.

Encouraged by this progress, I decided to try sharing it on Hacker News again. My first attempt with Version 1 had just a single upvote. This time, things were very different.

Share

When Your Experiment Goes Viral: The HN Moment

Watching your side project climb the ranks of Hacker News is equal parts thrilling and terrifying. Every design detail—and every flaw—is suddenly under the scrutiny of thousands of highly engaged and skilled technologists.

Teaching Dark Patterns, Creating New Ones

In a game designed to teach about dark patterns, I inadvertently created a few of my own.

One notable example was the Misdirection Pattern lesson, placed midway through the lesson sequence. After three lessons focused on teaching users to avoid dark patterns, this one flipped the script—it required players to intentionally fall for one. This abrupt shift in game logic confused players, effectively gaslighting them for the remaining questions. Many were left unsure whether the goal was to spot or succumb to dark patterns from that point onwards.

This misstep was a stark reminder: focusing too much on individual components can blind you to the overall user journey. By optimizing for isolated scenarios, I’d unintentionally undermined the game’s larger educational experience. It was a humbling lesson in maintaining consistency and clarity when designing for learning.

Design Decisions at Scale

Small design choices I made early on revealed larger UX issues when tested at scale:

• Automatic timers: I had a 3-second timer for automatic progression after completing lessons that was too quick for many users. During a peak-traffic hotfix, I extended it to 5 seconds while fixing a background rendering issue. I justified it as partly for chaos, partly for science—what better time to test user patience than when thousands are actively engaged? Unsurprisingly, it frustrated others. A full rework became necessary in the next update.

• No lesson skipping: Early versions required clear, sequential instructions to compensate for the lack of navigation flexibility. But when navigation was later made flexible, those same explicit instructions turned the experience into a dull clicking exercise rather than an engaging puzzle.

Deep Engagement and Feedback

The feedback from users extended beyond content or pacing. Players engaged deeply with the game’s core concept, offering:

• Detailed critiques of question design, prompting the removal of weaker lessons.

• Validation of the concept’s educational potential and ideas for growth.

• Specific suggestions to improve game mechanics.

• Insights into technical issues I’d overlooked as a novice developer.

• Feedback on device-specific experiences, particularly on mobile.

The mobile experience was especially eye-opening. Fancy background animations that looked great on desktop crippled performance on smaller devices. Navigation designed for desktop felt clunky on touchscreens. Perhaps most surprising, mobile users made up over 60% of all players—far more than I had anticipated.

The Value of Public Feedback

For a product creator, this kind of engaged feedback is pure gold. Controlled user research sessions might yield polite suggestions, but seeing thousands of real users actively engaging and debating improvements with brutal honesty was like mainlining pure user insight.

The engagement from the Hacker News community lit a fire under me. Thousands of users found enough value in the game to give it a try, and many shared it or offered thoughtful feedback. That response gave me the motivation to iterate further, transforming this experiment into something more complete.

Subscribe now

Listening, Learning, and Leveling Up

When thousands of users encounter your product at once, the challenge isn’t finding what to fix—it’s deciding what to fix first, especially when you’re handling everything yourself. To stay focused, I asked myself one question:

What changes would most improve the learning experience and best serve the user’s interests?

Setting Expectations

The first improvement was adding an onboarding screen before the lessons. This set clear expectations—a kind of mini contract between the game and the player—and gave me a framework for evaluating future updates.

Optimizing for Engagement

My biggest priority was optimizing mobile performance and reworking the lesson flow. I implemented a two-stage system for each question to improve clarity and engagement:

1. Stage 1: The challenge, with better context to help users understand how to interact with the scenario.

2. Stage 2: Informative content, providing detailed explanations and reflections to reinforce learning.

This structure allowed users to:

• Actively engage with the interactive challenges first, making the experience more intuitive and immersive.

• Reflect and learn through deeper content afterward, giving context and meaning to their actions.

• Control their pace while keeping the educational concepts distinct from the tasks.

Clarifying the Content

I reworked each lesson to answer three guiding essential questions for the user:

1. What is this dark pattern?

2. Why does it matter?

3. Where might you encounter it?

This clarity ensured that every interaction had purpose and left no ambiguity.

Unlocking Unexpected Use Cases

What surprised me most was how people envisioned using the game:

• Educators saw its potential for classrooms.

• Privacy advocates saw it as a tool for helping older and younger adults navigate digital spaces.

These unexpected use cases validated the game’s educational focus and opened exciting possibilities for future iterations.

Share

Lessons from Building in Public

Looking back, I’m grateful I didn’t wait for perfection. If I had tried to build the “complete” version first—as I’ve done with many half-finished projects—I might still be tinkering in isolation. By starting small but functional, I learned from thousands of real users what actually mattered.

The most powerful insight wasn’t about specific features or bugs—it was about approach. Every product manager talks about user-centered design and iterative development, but experiencing it firsthand—watching real people engage with something you’ve built—brings those principles to life in a way no framework ever can.

The most valuable lesson from building in public?

Your assumptions will be wrong, and that’s okay.

The key is making space for these discoveries early, while your product is still flexible enough to adapt. By keeping the core experience simple, I created room to learn from users who showed me what they actually needed—not what I assumed they wanted.

I hope that sharing the evolution of this project—and the reasoning behind the decisions I made—serves as a helpful case study for others. Whether you’re designing games, building tools, or working on entirely different challenges, the same principles apply:

• Start small but intentional.

• Stay open to feedback and surprises.

• Iterate thoughtfully based on real-world engagement.

The dark patterns game—and future games—will continue to evolve. Each update brings new insights, new opportunities for improvement, and inevitably, new challenges. But now, it’s growing with purpose, shaped by feedback from a community that cares about digital literacy as much as I do.

Great products aren't born from perfect plans—they emerge when we're brave enough to put our experiments in front of real users and learn from them.

Keep Iterating,
—Rohan

P.S. If you want to play the game for yourself, you can give it a go here.

Help me decide what to write about next by answering this poll:

Share

Thanks for reading! If you’ve found value in these ideas, there are three simple ways to share your support:

1. Like and Share: Spread these ideas to others who they may resonate with.

2. Subscribe for Free: Get future posts delivered straight to your inbox.

3. Become a Paid Subscriber: Support my work (and caffeine addiction).

Subscribe now

Let’s connect! Find me on LinkedIn, Bluesky, Threads, X, or drop me an Email. I’m always open to interesting discussions and opportunities.

I love AI tools today, but I'm glad they weren't around during my university years. I often think about how different my experience and path would have been if I had been at university now.

It's a strange thing to say, isn't it?

In an era where we celebrate innovations that make life easier, being thankful for doing things the hard way feels counterintuitive.

But here’s the thing: Learning isn't supposed to be easy. The resistance we feel when wrestling with a new concept, the frustration of solving a tough problem—these aren't bugs in the learning process. They're features.

Looking back on my journey into product, the moments that shaped me weren't when everything clicked smoothly into place. They were the times I pushed through uncertainty, wrestled with complexity, and failed before succeeding.

Those struggles didn't just teach me design skills—they shaped how I think about helping others solve real problems.

The Power of Productive Struggle

In my early days conducting product demos, I noticed a fascinating pattern. Polished presentations, where I explained everything step-by-step, left users nodding in understanding. But in follow-ups, it was as if they'd never seen the product before. The information hadn't stuck.

Everything changed when I flipped the script and let users drive. I guided them through a screenshare while they explored. It was slower and messier, but the difference was striking: not only did they remember how things worked, but they also felt confident enough to tackle problems on their own.

This experience revealed a deeper truth: in our rush to eliminate friction and maximize convenience, we might be sacrificing something essential—the resistance that helps us truly understand and master new skills.

While reducing friction often makes sense in sales and marketing, building products that truly help people learn and grow requires a different approach. In these cases, some resistance isn't just inevitable—it's essential for meaningful progress.

Understanding Value-Creating Friction

Not all friction is created equal. Some things really do just get in our way, while others push us to think deeper and learn better. The challenge isn’t making everything easy—it’s figuring out where a bit of struggle actually helps.

Here are four ways I’ve found that friction fosters learning and improvement:

1. Active Learning
True understanding comes from working through problems ourselves. It’s the difference between watching someone code and writing your own program, between seeing someone use a tool and figuring it out yourself. Yes, it’s slower. Yes, it’s harder. But that’s exactly why it works. When you have to connect the dots or work through confusion, you build knowledge that lasts.

2. Creative Exploration
Unexpected solutions come when we have room to explore. When using products, we often follow a predefined path. But when we have space to test ideas and try different approaches, we discover better ways to solve problems. It’s messier than following a guide, but it leads to creative breakthroughs.

3. Stretch Challenges
Growth happens when we push beyond our comfort zones. Learning a new design tool, tackling a programming language, or mastering public speaking—these challenges build lasting skills. Struggle is the engine of improvement.

4. Skill Refinement
Confidence comes from practice. Understanding something conceptually is one thing; using it effectively when it matters is another. Through repetition and active use, we turn knowledge into reliable skills.

Share

Rethinking Our Approach

I recently experienced this from the other side when I created Dark Patterns Detective, an educational game about deceptive UX practices. When the game gained organic traction, nearly 2,000 people engaged in a single day—despite, or perhaps because of, its intentional friction.

Instead of passively consuming information, players had to think, engage, and solve problems. The feedback was clear: those challenges made the learning stick. In a world where we often forget what we scroll through mere moments later, the game’s friction created a memorable experience.

Instead of asking, "How can we make this easier?" we should ask:

• Where does embracing difficulty lead to deeper learning?

• What types of challenges drive meaningful improvement?

• How can we inspire people to engage more deeply with the process?

• When does overcoming resistance create lasting value?

The Path Forward

This doesn't mean making things needlessly difficult. The goal isn't to add friction for its own sake, but to be thoughtful about where a bit of resistance helps people get better at what they're trying to do.

As AI and automation advance and continue to “eat the world”, this becomes even more important. We need to be careful about preserving the kinds of challenges that help people learn and improve, while removing the ones that just waste their time and energy.

In the end, our goal isn't just to make things easier—it's to build tools that help people thrive. And sometimes, thriving means embracing the productive struggle that leads to real learning.

Thanks for reading!

Share

How you Can Support Product Artistry:

If you’ve found value in these ideas, there are three simple ways to support this work:

1. Like and Share: Spread these ideas to others who might benefit from them.

2. Subscribe for Free: Get future posts delivered straight to your inbox.

3. Become a Paid Subscriber: Support my independent journey and help sustain Product Artistry.

Subscribe now

Let’s Connect:

I’d love to hear from you! Connect with me on LinkedIn, Bluesky, Threads, X, or drop me an Email. I’m always open to interesting discussions and collaborations.

Keep Iterating,
—Rohan

What began as a small experiment and creative outlet in March 2024 has grown into a community of over 600 curious minds spanning 71 countries, exploring fresh perspectives on product thinking. Together, we’ve uncovered how small decisions can ripple into larger impacts through frameworks, case studies, and mental models.

As we step into a new year, it feels like the perfect time to reintroduce myself and provide a guide to help both new and returning readers navigate Product Artistry. With 38 posts published so far, there’s plenty to discover!

Share

Welcome to Product Artistry

👋 Hi, I’m Rohan. I’m fascinated by how structure and creativity come together to create great products.

My journey spans civil engineering, insurance, and product management in cybersecurity. Across these fields, I’ve explored risk management and creative problem-solving. Over time, I’ve realized that the best products emerge at the intersection of structured thinking and creative exploration—where fresh ideas solve old problems and create real value.

Making products is both an art and a science.

It’s about blending business strategy, design empathy, entrepreneurial boldness, and technological possibilities. When we get this mix right, products don’t just work—they resonate and build a better future.

The name Product Artistry reflects this: structured thinking meets creative possibility. Design isn’t just how something looks—it’s the thoughtful decisions behind how it works and feels.

Why It Matters:
Every product decision creates ripple effects. A small feature can reshape behaviors, set expectations, or even transform industries. That kind of power calls for bold ideas and careful thinking.

This isn’t just about building better products—it’s about understanding how what we create shapes the world and owning that responsibility.

Start Your Journey: Reading Directory

Explore Product Artistry through this organized directory of posts, curated to help you dive into the art and science of building meaningful products:

🏆 Most Popular

• Business Models as Product Strategy: How incentive design shapes successful products

• How Risk Fuels Product Innovation: Turning challenges into breakthrough opportunities

• Why B2B Products Fail Without Mastering Value Translation: Master value translation to win across every audience

🎯 Strategic Foundations

• The Three Waves of Product Impact: How solutions cascade into cultural forces

• Understanding Market Acceptance: Using the Overton Window to shape innovation

• The Competitive Slingshot Effect: How startups turn market leaders' gravity against them

💡 Mental Models & Thinking

• Think Like an Engineer, Create Like an Artist: Bridging systematic and creative thinking

• Counterintuitive Thinking in Product Strategy: Solving problems by challenging assumptions

• The Daydreamer’s Guide to Product Sense: Seeing products as they are—and could be

• Hidden Signs You’re Solving the Wrong Problem: Why friction points to deeper flaws

• A Product Manager's Insights in Newsletter Creation: Strategies for sustainable growth and iterative development

🎨 Design Psychology

• Beyond the Wait: The Evolution of Loading Bars: How loading experiences shape user experience

• Mining Minds: The Genius of the Modern Search Box: How search boxes have redefined information gathering and their next evolution in AI products

• Dark Patterns Detective: A mini-game tool for learning to spot manipulative design practices

🚀 Growth & Innovation

• Why Great Ideas Get Watered Down: Keeping MVPs bold while scaling

• Growth Hacking Through User Content: Leveraging community and UGC for growth

• How Platform Ecosystems Drive Growth: Unlocking scalable innovation flywheels

• The Engagement Game: Why gaming is embedding itself in all platforms

• Audience-First Product Strategy: Harnessing distribution to drive product success in the attention economy

• Productization in the Creator Economy: Leveraging product strategy to build resilient creator businesses

🌟 Case Studies

• Hidden in Plain Sight: Honey’s $4B Strategy: How a browser extension embedded itself in e-commerce’s most valuable moment

• The Art of Going Viral: Spotify Wrapped: The strategic brilliance behind Spotify's yearly product marketing sensation

• How the Apple Watch Shapes Healthier Habits: Leveraging behavioral design for wellness, engagement, and user empowerment

(Directory last updated: January 2025)

🪡 Help Me Tailor Future Content For You!

I’d love to hear about your challenges and interests so I can create content that’s even more valuable for you. Take a moment to share your thoughts in this quick questionnaire—it would mean a lot to me:

Tell Me What You’d Like to See

How You Can Support Product Artistry:

If you’ve found value in these ideas, there are three simple ways to support this work:

1. Like and Share: Spread these ideas to others who might benefit from them.

2. Subscribe for Free: Get future posts delivered straight to your inbox.

3. Become a Paid Subscriber: Support my independent journey and help sustain Product Artistry.

Subscribe now

Keep Iterating,
—Rohan

Let’s Connect:

I’d love to hear from you! Connect with me on LinkedIn, Bluesky, Threads, X, or drop me an Email. I’m always open to interesting conversations and opportunities!

Behind the friendly gold coin mascot lay something far more strategic: a product designed to capture the most critical juncture in online shopping.

Most saw Honey as a simple browser extension that found discount codes. But that simplicity was its greatest strength. A recent viral investigation by YouTube creator MegaLag (whose in-depth video I highly recommend) revealed a more complex reality:

• Silently adjusting affiliate tracking to capture commissions

• Redirecting millions in commission revenue

• Positioning itself between retailers and customers

• Influencing behavior at the peak of the shopping journey

The genius of Honey’s strategy lay in making every stakeholder feel they were gaining, even as it quietly redefined how value flowed in e-commerce:

• Users believed they were saving money effortlessly.

• Creators were drawn in by attractive upfront sponsorship payments.

• Retailers welcomed improved conversion rates and additional sales.

Yet beneath the surface, Honey fundamentally reshaped the dynamics of the marketplace.

By the time PayPal acquired Honey in 2020 for $4 billion in cash, the browser extension had embedded itself so deeply into online shopping that its influence was nearly impossible to displace.

This is a story about modern platform power: sometimes the most effective way to reshape an industry is to embed yourself in its most critical moments.

Let’s deconstruct how they did it.

1. The Fundamental Strategy: Control the Checkout

Every successful platform needs a wedge—a strategic entry point that unlocks disproportionate power. Honey found theirs in a profound insight: whoever controls the checkout moment controls e-commerce itself.

While competitors focused on discovery and browsing, Honey targeted the single most valuable microsecond in online shopping: the moment you commit to purchase. This wasn’t a random choice—it was a deliberate strategy based on three critical advantages:

• Users were psychologically primed to take action.

• Attribution systems were vulnerable to manipulation.

• The potential for value capture was highest at this stage.

But identifying this opportunity was just the beginning.

1.1. The Attribution Hijack

At the heart of Honey’s strategy was something most users never consider: how online stores track who gets credit for a sale. In e-commerce, the predominant system used is called last-touch attribution—the commission goes to whoever interacted with the customer last, even if someone else did all the work to drive the sale.

Think of it like this: A YouTuber reviews a product, and you click their link to buy it. In theory, they should get credit for the sale. But if you interact with Honey before completing your purchase, it overrides their credit entirely.

Here’s how it worked:

1. Initial Journey:

   • A creator shares a product review with their unique affiliate tracking link.

   • You click through to the store, add items to your cart, and proceed to checkout.

   • Behind the scenes, the store sets the creator’s tracking cookie to credit them for the sale.

2. The Perfect Moment:

   • You reach the checkout page, ready to purchase.

   • Honey’s “Apply Coupons” button appears—exactly when price matters most.

   • Behind the scenes, Honey monitors this precise moment.

3. The Switch:

   • You click the tempting “Apply Coupons” button, hoping to save.

   • Behind the scenes, Honey silently:

     • Opens a side tab with its own affiliate link.

     • Overrides the creator’s tracking cookie.

     • Closes the tab instantly, ensuring you never notice.

4. The Result:

   • You see whether any coupons worked.

   • Behind the scenes, Honey claims the commission value—regardless of whether savings were applied.

Most users never realized what happened. Their focus was on potential savings, not the invisible manipulation in the browser backend. Even if no coupons worked, Honey still captured the commission value.

Example: The MegaLag Investigation

MegaLag's controlled test using his own NordVPN affiliate links revealed the stark reality of Honey's value capture:

• Without Honey: MegaLag, as the original referrer, earned the full $35.60 commission for a NordVPN sale.

• With Honey: The platform redirected 97.5% of the value ($34.71) to itself.

  • Creator earned: $0.

  • User received: $0.89 in rewards points for facilitation (2.5% of the original value).

This test demonstrated how Honey leveraged its position at checkout to redirect commissions, even when coupons didn’t provide any additional savings.

This wasn’t just clever engineering—it was systematic value capture at scale. Honey positioned itself perfectly:

• Legitimacy: Users had a compelling reason to click (potential effortless savings).

• Timing: It struck at peak purchase intent when users were most receptive.

• Invisibility: The redirection happened seamlessly, unnoticed by users.

By controlling the checkout moment, Honey wasn’t just offering potential savings—it was quietly redirecting millions in commission revenue, all while users remained unaware.

1.2. The Technical Innovation

Honey’s success wasn’t just about finding coupons—it was about leveraging browser-level integration to operate at massive scale. By embedding itself in the browser, Honey unlocked capabilities that traditional platforms couldn’t match:

• Real-Time Monitoring: Honey observed shopping behavior, tracked price sensitivity, and mapped user journeys across thousands of sites, all while presenting itself as a simple coupon tool.

• Seamless Integration: The extension worked behind the scenes to streamline affiliate tracking, optimize attribution, and ensure a frictionless user experience.

• Unbounded Scalability: Honey operated globally, adapted to virtually any retailer’s site, and scaled effortlessly to millions of users.

This was more than just clever engineering—it was a strategic innovation. Honey positioned itself directly in the checkout flow, capturing value at the most critical moment of the user journey.

Unlike traditional platforms that relied on retailer partnerships, Honey’s browser-based approach allowed it to operate independently, integrating with purchase flows across the web.

Honey wasn’t just a coupon finder. It became an invisible layer that bridged users and retailers—delivering value, learning from interactions, and optimizing its approach—while remaining nearly invisible.

1.3. The Data Advantage

Honey’s universal positioning gave it something even more valuable than commission revenue: unprecedented insight into online shopping behavior. Every user generated data that reinforced Honey’s position:

• Purchase Intent: By analyzing customer behavior, Honey mapped the triggers behind buying decisions.

• Price Sensitivity: It identified the discounts that drove purchases across categories and demographics.

• Cross-Platform Intelligence: With visibility across thousands of retailers, Honey uncovered patterns no single merchant could access.

This data advantage created a powerful flywheel effect:

1. Better data led to deeper insights.

2. Deeper insights strengthened retailer relationships.

3. Stronger relationships drove more user adoption.

4. More users generated even richer data.

Retailers increasingly relied on Honey’s insights to optimize pricing, predict trends, and understand customer behavior across the shopping journey.

While users saw a tool for saving money, Honey was quietly building one of the most sophisticated e-commerce intelligence platforms in the world.

Share

2. The Perfect Moment: Engineering Trust Through Psychology

Building the infrastructure to capture attribution was only half the battle. Honey needed users to willingly trigger it—and their solution was brilliant in its simplicity.

2.1. The Perfect User Moment

Picture this: You’re at checkout, cart full, credit card in hand. The total feels steep. Then, a small modal appears: “5 Coupons Found! Apply Coupons?”

What happens next is a masterclass in behavioral design:

• If coupons work: Your total drops instantly—a dopamine hit that validates both your purchase and Honey’s value.

• If coupons fail: You still earn PayPal Rewards points for trying, ensuring every interaction feels like a win.

This wasn’t just clever design—it was a textbook implementation of ’s Hooked Model for habit-forming products:

• Trigger: The checkout moment creates price anxiety.

• Action: The “Apply Coupons” button offers an effortless solution.

• Variable Reward: Either savings or reward points ensure user satisfaction.

• Investment: Each successful use builds trust and a habit for future purchases.

Behind this simple interface, Honey was executing a fine-tuned psychological system designed to maximize engagement:

• Show the Work: Users saw Honey visibly testing multiple codes, creating trust through transparency.

• Guarantee a Win: Whether through savings or rewards, users always left feeling they’d gained something.

• Create Zero Risk: Clicking the button had no downside but promised plenty of potential upside.

2.2. The Frictionless Design

Honey’s brilliance extended beyond psychological hooks—it eliminated every possible barrier to adoption for the product:

• Zero Cost: Free to install, with no perceived risk.

• Zero Effort: Automatically worked across thousands of sites.

• Zero Learning: A simple, intuitive interface required no training.

• Zero Wait: Users saw immediate value from their very first use.

This seamless experience transformed Honey from a niche tool into a universal shopping companion. Users didn’t have to remember to use it, configure settings, or navigate complex features—it was always there, ready to help.

2.3 The Perfect Product-Moment Fit

This combination of psychological hooks and frictionless design wasn’t just good product thinking—it was perfect strategic positioning. Honey identified the ideal moment to integrate itself into e-commerce:

• Peak Psychological Vulnerability: Users felt the most price anxiety just before completing a purchase.

• Lowest Resistance: The decision to buy was already made, removing major friction.

• Maximum Value Perception: Savings felt the most rewarding at checkout.

• Perfect Attribution Timing: Users triggered the commission capture themselves.

This positioning allowed Honey to serve multiple strategies at once:

• For Attribution: Enabled Honey to override creator cookies at checkout.

• For Data: Captured purchase intent at its most revealing point.

• For Trust: Demonstrated value when users needed it most.

• For Lock-in: Created an association with the satisfaction of saving.

By owning this critical moment, Honey didn’t just position itself as a helpful browser extension—it became the gatekeeper of purchase completion.

Subscribe now

3. The Market Power Play: How Honey Shaped the Game

Honey's success wasn’t just about technology or psychology—it was about creating a system where data insights shaped user behavior and market dynamics. By collecting and analyzing critical transaction data, Honey built a unique information advantage that powered its strategy.

At the checkout moment, Honey would have visibility into:

• Purchase patterns and price sensitivity across user segments.

• Attribution data showing which creators influenced sales.

• Real-time pricing and discount strategies from retailers.

• Conversion data and cart abandonment patterns.

This data advantage allowed Honey not just to observe but to strategically influence the marketplace. It optimized when and how to surface deals, targeted promotions effectively, and strengthened its position with both shoppers and retailers through data-driven decision-making.

3.1. Engineering Inevitability

Honey created powerful network effects and incentive structures that made participation increasingly valuable—and costly to avoid—for all stakeholders:

• Users: Relied on automated savings, especially as prices rose, making Honey indispensable for deal-seeking shoppers.

• Creators: Were drawn to Honey’s lucrative sponsorship model, even as it subtly increased their dependence on the platform.

• Retailers: Valued Honey’s consumer behavior insights and sales boosts, particularly in the face of competition from giants like Amazon.

By aligning these incentives and creating high switching costs, Honey evolved from a simple coupon tool into a dominant e-commerce intermediary.

3.2. The Retailer's Dilemma

Honey presented retailers with a compelling yet complex value proposition:

1. Benefits of Partnership

   • Access to Honey’s growing user base and increased conversion rates.

   • Revenue via affiliate commission structures.

   • Consumer behavior analytics offering valuable insights.

   • Some control over discount strategy and promotion timing.

   • Integration with a widely used e-commerce platform.

2. Costs of Non-Participation

   • Risk of losing price-sensitive customers to competitors using Honey.

   • Limited visibility into shopping patterns and market trends.

   • Honey users could still find and apply coupons, bypassing retailer influence.

   • A perception of being less consumer-friendly in a deal-driven market.

While partnering with Honey offered immediate sales and market benefits, it also shifted market power over time. Retailers would become increasingly reliant on Honey for customer acquisition and retention, further deepening the platform’s influence.

3.3. The Creator’s Strategic Trap

Honey’s relationship with creators revealed a tension between short-term benefits and long-term dependency:

1. Initial Partnership Benefits

   • Lucrative sponsorship deals provided attractive revenue opportunities.

   • Marketing messaging aligned with creator goals, fostering trust.

   • Early adopters saw strong returns, reinforcing positive perceptions.

2. Evolving Revenue Impact

   • Affiliate tracking was overridden at checkout.

   • Commission attribution shifted to Honey.

   • Honey captured significant value from creator-referred traffic.

Even creators who recognized this dynamic were trapped. As Honey’s user base grew, the likelihood of viewers using the extension increased, systematically eroding affiliate revenue—regardless of the creator’s actions.

3.4. The User Capture

While users appeared to benefit the most, they were also central to Honey’s growth and market dominance:

• Building Loyalty: Consistent savings turned Honey into a trusted shopping companion, driving repeat usage.

• Word-of-Mouth Marketing: Positive experiences encouraged users to share Honey with others, creating organic growth.

• Driving Network Effects: Each user interaction enriched Honey’s data engine, amplifying its influence across retailers and creators.

Honey turned user behavior into a self-reinforcing growth engine and a competitive moat. The more users joined, the stronger Honey’s position became, creating a cycle that was difficult for competitors to disrupt.

3.5. The Perfect Game

Honey’s success lay in crafting distinct perceptions for each stakeholder group:

1. Users saw:

   • Perception: A free tool delivering automatic savings.

   • Reality: Their shopping behavior fueled Honey’s data engine and market power.

2. Retailers saw:

   • Perception: A powerful sales optimization platform.

   • Reality: Growing dependency on Honey for customer acquisition and insights.

3. Creators saw:

   • Perception: A valuable marketing and monetization partner.

   • Reality: Systematic redirection of affiliate revenue to Honey.

Honey’s multilayered strategy demonstrated mastery of platform dynamics: while stakeholders perceived immediate benefits, their engagement deepened Honey’s control over the market.

Through consistent value delivery, Honey grew its ecosystem while embedding dependencies at every level.

Share

4. Conclusion: The Hidden Cost of Platform Power

Honey’s rise shows how digital platforms can transform industries by embedding themselves at critical transaction points—delivering seamless user value while quietly reshaping how the market operates. Their $4 billion exit wasn’t just a triumph of engineering; it was a masterclass in systematic value capture.

One theme stands out: Honey’s success was built on a deep understanding of user psychology, precise market positioning, and the ability to leverage data at scale. Yet, their story also highlights the risks of growth strategies fueled by misaligned incentives:

• Users saved money but unknowingly participated in revenue redirection.

• Creators enjoyed early rewards but saw declining earnings as commissions shifted.

• Retailers benefited from tools and insights but would become increasingly dependent on Honey’s ecosystem.

These dynamics leave us with pressing questions about the future of platform strategies:

• What are the long-term costs when platforms prioritize growth over ecosystem health?

• How can platforms balance rapid innovation with sustainable stakeholder relationships?

• Is there a fundamental tension between platform scale and equitable value distribution?

Honey’s playbook offers both inspiration and caution for the next generation of platform builders. The challenge isn’t simply identifying and exploiting untapped leverage points—it’s about using that leverage responsibly to ensure sustainable, long-term growth.

It’s clear that powerful platforms can be built—Honey proved that decisively. The real challenge lies in creating platforms that maintain healthy market dynamics and ensure growth comes from genuine value creation, not zero-sum games.

Sometimes, the cleverest strategy isn’t the best one. The best strategies create lasting value for everyone involved.

Note: This analysis is based on publicly available information. Some technical details involve informed speculation rather than definitive claims about specific business practices.

Three ways to help support my work:

1. Like, Comment, and Share—Help increase the reach of these ideas.

2. Subscribe for free—Get future posts and join our community.

3. Become a paid subscriber—Support my independent journey.

Keep Iterating,
—Rohan

→ Connect with me: LinkedIn, Bluesky, Threads, X, or Email—I’m always open to interesting conversations and opportunities!

Solving problems in real time felt thrilling. Each fix, customer call, and custom implementation delivered tangible results, fueling momentum and growth.

But over time, I noticed something: the work that had once felt like a superpower was slowly becoming a burden.

Here’s the lesson I learned rather quickly:

Manual work is invaluable for learning early, but every process has an expiration date.

What starts as a driver of success eventually becomes a bottleneck. That’s when evolution becomes essential—not just for workflows, but for your team and its goals:

• Prevent burnout by reducing repetitive tasks.

• Stay focused on high-value work instead of distractions.

• Build scalability into systems that grow with you.

Knowing when to evolve is hard. Starting before things break is even harder. But it’s the only way to avoid getting trapped by the very processes that built you.

Scaling Is Like a Jenga Tower

Scaling a team or product is like building a Jenga tower:

• Every new layer depends on the stability of what’s underneath.

• Unstable blocks—those old, manual workflows you never replaced—don’t just stay unnoticed. Over time, they make the tower harder to balance.

At first, the wobble seems small:

• A manual process here.

• A workaround there.

But as you scale, every new layer adds more pressure. What started as a minor instability grows into a risk that affects the entire structure.

The risk? You keep adding layers, hoping the tower holds—until one day, it doesn’t.

Your choice:

1. Carefully remove and replace the unstable blocks, strengthening your foundation.

2. Keep stacking—and risk a collapse that disrupts everything you’ve built.

Yes, reworking your workflows takes time and effort.

But the alternative? Watching all your progress topple because the base wasn’t built to scale.

When Manual Work Stops Teaching You

The instability in your foundation doesn’t come from one big mistake—it’s the slow accumulation of old workflows that no longer serve you.

Manual work, once your biggest strength, stops delivering value when it stops teaching you something new.

At first, manual workflows are invaluable. They help you:

• Learn directly from customers.

• Identify edge cases and opportunities.

• Uncover patterns that shape your strategy.

But here’s the problem: that learning doesn’t last forever.

Over time, the signals become noise:

• Customer interactions feel routine, not revealing.

• Quick fixes turn into slow, frustrating workarounds.

• Repetition drains energy instead of fueling momentum

Worse, manual processes can create information silos that fragment your team.

• Teams working in isolation rely on outdated information or inconsistent methods.

• Misalignment and duplication of effort become common.

• Valuable insights get trapped in inboxes, spreadsheets, or individual minds—out of reach for the broader team.

When manual work stops being insightful, it starts being costly.

Hidden inefficiencies accumulate, creating process debt that:

• Drains your team’s focus.

• Stalls innovation.

• Saps morale.

These aren’t signs of failure—they’re signs of success pressing against its limits. Recognizing these limits is the first step toward building something better.

Share

Solution Framework: Evolving Your Workflows

The hardest part about evolving workflows isn’t just recognizing the faults in your foundation—it’s acting before they become unfixable. Most teams fall into one of two traps:

1. They wait too long. By the time they act, inefficiencies have compounded, making fixes feel overwhelming and disruptive.

2. They overcorrect. In their rush to automate or streamline, they lose the flexibility and insights that manual work once provided.

The key is to approach evolution systematically, not reactively.

Here’s how:

1. Evaluate Manual Work with a Clear Framework

Not all manual work needs to change—some of it is essential to what makes your team and product thrive. The goal isn’t to eliminate manual processes entirely—it’s to optimize them, keeping what works and evolving what doesn’t.

Here’s a decision matrix to help you evaluate workflows and prioritize what needs to evolve:

• High Learning, Low Cost (Top Left Quadrant) → Keep Manual:
  Early-stage customer calls, user interviews, or prototyping that generate actionable insights.

• High Learning, High Cost (Top Right Quadrant) → Watch Closely:
  Custom integrations or complex workflows that teach you something critical but are resource-intensive.

• Low Learning, Low Cost (Bottom Left Quadrant) → Automate When Ready:
  Routine status updates, standard exports, or other predictable tasks that no longer require human input.

• Low Learning, High Cost (Bottom Right Quadrant) → Evolve First:
  Repetitive tasks like manual data migrations or approvals that drain resources without adding value.

Prioritize evolving high-cost, low-learning processes—they drain resources without adding value.

2. Evolution Triggers: Know When to Act

Waiting until a process breaks isn’t a strategy—it’s a liability. The impact often extends beyond workflows, affecting your team’s morale and productivity. That’s why it’s crucial to recognize these triggers early and flag them for action:

• Learning Plateau: Workflows stop generating new insights or patterns.

• Process Lag: Once-quick tasks take disproportionately longer.

• Team Burnout: Repetitive, low-value work drains energy and motivation.

• Scalability Stress: Growing customer demand pushes processes—and people—beyond their limits.

Define these triggers clearly and ensure they’re understood across your team. Proactively monitoring for them allows you to address inefficiencies before they cascade into larger issues.

Process evolution isn’t just about fixing broken workflows—it’s about building awareness and adaptability into your team’s approach.

3. Evolve Gradually, Not Dramatically

Recognizing triggers is only the first step. The real challenge lies in evolving workflows without disrupting your team or losing momentum. The best time to make changes is when processes are still functioning—but just barely. This gives you room to act deliberately rather than reactively.

Here’s how to evolve workflows effectively:

• Start Small: Identify a single high-cost, low-learning process to refine or automate.

• Test Incrementally: Pilot new tools or workflows with a small team before scaling changes across the organization.

• Focus on Modularity: Build improvements that integrate with existing systems and can scale gradually.

This method ensures that workflow evolution is manageable, minimizes disruptions, and keeps your team aligned as you adapt.

Evolving Without Losing What Made You Great

It’s tempting to think of process evolution as a sacrifice—letting go of the manual work that got you here. But evolution isn’t about erasing those early workflows; it’s about honoring them by building something better.

• What made manual work valuable wasn’t the effort—it was the insights.

• Evolving doesn’t mean losing flexibility—it means channeling it more effectively.

By building systems that teach you, scale with you, and adapt over time, you can keep learning without falling into the traps of process debt.

Share

The Bottom Line: Know When to Let Go

Manual workflows are an essential part of growth—they teach you, shape your perspective, and drive early results. But they’re not meant to last forever.

The best teams don’t evolve because they’re forced to—they evolve because they want to focus on what matters most:

• Learning: Staying curious and open to new insights.

• Iterating: Continuously improving based on those insights.

• Building: Creating systems and solutions that can sustain long-term growth.

The work that once built you doesn’t have to break you. When you let it evolve, it becomes the foundation for something even stronger.

By embracing change, you free yourself to focus on what really drives progress: solving new problems, uncovering fresh opportunities, and building systems that grow with you.

Three ways to help support my work:

1. Like, Comment, and Share—Help increase the reach of these ideas.

2. Subscribe for free—Get future posts and join our community.

3. Become a paid subscriber—Support my independent journey.

Keep Iterating,
—Rohan

→ Connect with me: LinkedIn, Bluesky, Threads, X, or Email—I’m always open to interesting conversations and opportunities!

There’s a painful irony in how we build MVPs today: we water down bold ideas in the name of “starting small,” only to miss the very insights these experiments are meant to uncover.

Conventional wisdom tells us to be conservative:

• "Let's be realistic here..."

• "We can innovate after we get traction..."

• "Users expect certain features..."

But this approach creates a dangerous paradox:

By trying to de-risk our experiments, we actually increase the risk of building something nobody wants.

Think about it—if your MVP is meant to test your boldest assumptions and learn quickly, shouldn’t it lean into what makes your idea different rather than hide it?

The MVP Dilution Pattern

Here’s a controversial take:
We’re far too obsessed with competitor analysis when building MVPs.

Early in my career, I worked in an emerging product category. It quickly became clear that in a new market, everyone is just guessing.

Copying competitors is like mimicking the person next to you during a test neither of you understands.

You might get lucky—but you’re just as likely to repeat their mistakes.

How Ideas Get Watered Down

Time and again, I’ve seen teams fall into this trap. They start with bold visions, rooted in genuine insights. But then something dangerous happens:

Ideas get watered down through a series of seemingly reasonable decisions:

• “If they’re doing it, maybe we should too...”

• “Nobody else does it that way...”

• “Start with the proven approach...”

Each choice seems sensible in isolation. But together, they create three fatal flaws that kill most products before they have a chance to matter.

1. You Blind Yourself to Reality

When teams copy competitors, they miss critical truths:

• You don’t know their context or what’s really working for them.

• You don’t know which features they regret building.

• You don’t know the problems they’re actually failing to solve.

Building based on assumptions about others’ decisions makes you a fool twice:

1. First, for guessing their context wrong.

2. Second, for abandoning your own unique insights.

2. You Lose What Makes You Different

Safe MVPs default to validating the obvious. You might confirm that users like slightly better notifications, but you’ll miss whether your bold, radical idea solves their deeper, more critical problem.

By prioritizing industry norms and competitor features, you dilute the very vision that set you apart.

What’s left?
A weaker, less compelling version of what’s already out there.

3. You Get Useless Feedback

Safe MVPs rarely succeed or fail in meaningful ways. Instead, they drift into a dangerous middle ground where neither outcome tells you if your core idea was right:

• Success feels tepid: “Users kind of like it.”

• Failure feels unsurprising: “We didn’t execute well enough.”

The result?
Neither outcome generates actionable insights to guide your next steps.

Your Edge: Your Unique Insights

Your greatest strength lies in your unique insights—the context of the experiences and observations that shaped your hypothesis.

This is what sets truly innovative products apart. When you dilute it with competitor features, you don’t just weaken your product—you miss the chance to test what truly matters.

Here’s the paradox:
The safer your MVP feels, the greater the risk that it becomes irrelevant.

Instead of learning from bold experiments, you’re left with a product that offers no clear path forward.

Share

A Framework for Bold MVPs

Building a bold MVP doesn’t mean ignoring practical constraints. It means focusing on what matters most: testing the assumptions that could make or break your vision.

Here’s how to do it:

1. Find Your Sacred Hypothesis

Every product has assumptions, but not all assumptions are equal. Some are important—others are sacred. Sacred hypotheses are the beliefs that everything hinges on.

Your sacred hypothesis is the one assumption that, if wrong, invalidates your vision entirely.

Most teams spread their MVP too thin, trying to validate everything at once. Instead, focus on this one core belief—because if this is wrong, nothing else will matter.

Think about it this way:
Even if your UI, performance, and features are flawless, would your product still matter if this assumption was wrong? That’s the question your sacred hypothesis answers.

Examples:

1. Figma’s Hypothesis Might Have Been:
   “Will designers embrace real-time collaboration as a fundamental part of their workflow?”

   • It wasn’t just about building a “better design tool.”

   • The hypothesis likely went deeper: if designers weren’t ready to shift from static to dynamic workflows, Figma’s entire vision of real-time collaboration would fail.

2. Slack’s Hypothesis Might Have Been:
   “Will teams shift away from email and adopt channel-based communication as their primary mode of interaction?”

   • It wasn’t just about building a “better chat app.”

   • Slack likely needed to validate whether teams could break deeply ingrained habits tied to email, or if they’d only use Slack as a supplemental tool.

These examples highlight how sacred hypotheses focus on behavioral shifts, not just product features or market size.

2. Design for Strong Reactions

Your MVP shouldn’t aim for broad appeal—it should seek polarizing responses.

The goal isn’t to make something everyone likes a little—it’s to find out if anyone loves it a lot.

Safe ideas often lead to vague, lukewarm feedback. What you need is clarity, and strong reactions—both positive and negative—are the best teachers.

Case Study: Notion
When Notion launched, it ignored traditional document organization norms like folder structures and separate apps for notes, tasks, or databases. Many enterprise users found it confusing, but knowledge workers who craved flexibility became its most vocal advocates.

The takeaway?
Polarizing responses validated Notion’s core assumption: some teams will trade familiarity for flexibility.

Focus your MVP design on features that explicitly test your sacred hypothesis, even if they challenge user expectations or norms.

3. Set Clear Learning Thresholds

Most MVPs fail, not because they don’t gather data, but because teams don’t know what data would change their minds.

Before writing a single line of code, you need to define clear thresholds:

• What evidence would validate your sacred hypothesis?

• What would invalidate it?

• What would tell you you’re asking the wrong question entirely?

Examples:

1. Figma’s Learning Threshold Might Have Been:
   “Do design teams stop exporting files for collaboration within their first week?”

   • If teams still exported files after using Figma’s collaborative tools, it would have signaled resistance to real-time workflows.

2. Slack’s Learning Threshold Might Have Been:
   “Does internal email usage drop by 80% within one month of team adoption?”

   • If email usage stayed the same, Slack would have known its hypothesis about replacing email as the primary communication mode needed to be revisited.

These examples highlight how learning thresholds force binary clarity—metrics so specific that you can’t rationalize ambiguous results.

4. Embrace Strategic Ignorance

The hardest part of building a bold MVP isn’t deciding what to test—it’s deciding what to ignore.

Every user interview will surface “critical” features. Every stakeholder will have their own “essential” priorities. The art lies in filtering out what doesn’t directly serve your sacred hypothesis—at least for now.

How to Focus:

• Be transparent about what you’re choosing not to test and why.

• Align with stakeholders early to avoid misaligned expectations.

• Remind yourself: You can always add features later, but you can’t retroactively test your sacred hypothesis.

Mindset Shift:
If you bury your sacred hypothesis under "must-have" features, you’ll never learn if your core assumption was right. You’re not saying no—you’re saying “not yet” to ideas that aren’t critical to your current learning goals.

Share

The Bottom Line

Building MVPs isn’t about creating something safe enough to launch—it’s about creating something bold enough to learn from.

Your MVP doesn’t need to be complete. It doesn’t need to be polished. It doesn’t even need to succeed.

But it must test your sacred hypothesis.

Here’s what most teams forget: Early adopters don’t want a watered-down version of what already exists. They want a glimpse of what could be.

They’re not looking for marginally better version of today—they’re looking for different.

So, give them different.

→ The risk isn’t in being wrong—it’s in being so careful that you never learn if you’re right.

Three ways to help support my work:

1. Like, Comment, and Share—Help increase the reach of these ideas.

2. Subscribe for free—Get future posts and join our community.

3. Become a paid subscriber—Support this creative journey.

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

→ I’m always open to interesting conversations and collaborations! Reach out at rohan@productartistry.com

Every product lives two lives: the one we experience today and the one it could become.

Most people only see the first life—the version that exists now. But there’s power in seeing both: holding the tension between reality and possibility.

As children, we did this instinctively. We questioned everything. We imagined how things could work differently. Somewhere along the way, many of us stopped doing that. I never did.

Instead, I turned it into a lens—a way of engaging with the world.

When I interact with a product, I see two realities:

• The present reality: shaped by constraints, compromises, and deliberate decisions. This is the world of trade-offs—the adult’s perspective where practicality often overshadows possibility.

• The imagined future: a world of hidden potential, where unrealized magic could transform the experience. This is the child’s perspective, where anything feels possible, and questions flow freely.

Great products emerge when someone can seamlessly toggle between the current state and what’s possible, bridging practicality with imagination.

This duality isn’t just for designers or product managers. It’s a mindset anyone can adopt. After all, we’re all users of countless products every day. Each interaction is a chance to ask: “What could this become?”

But imagination alone isn’t enough. The real magic happens when we bridge the gap—when we capture these observations and turn them into insight. This is where breakthrough products are born: in the space between what is and what could be.

From Observation to Insight

Seeing both lives of a product is just the start. The real breakthroughs come from capturing these moments and turning them into an archive of possibilities.

For me, this means journaling daily. My entries aren’t elaborate—just quick captures of thoughts, ideas, and patterns:

• A sketch of how a flow could work differently after experiencing friction.

• A screenshot of a feature that solves a problem elegantly.

• A few bullet points about a pattern I noticed, hinting at deeper needs.

They’re nothing fancy—just fragments of reality and possibility, saved before they fade. But over time, these fragments tell a larger story.

What do I capture? Moments that make me pause:

• When a product interaction reveals hidden opportunities.

• When I notice myself creating a workaround—a signal that the current solution isn’t right.

• When patterns reveal unmet needs hiding in plain sight.

These observations often sit quietly in my notes for months, collecting and connecting in the background. But when the right problem arises, they become invaluable—like having a conversation with my past self about ideas I once glimpsed but wasn’t ready to use.

At its core, this practice is about keeping that childhood wonder alive. Not just seeing the world as it is, but collecting glimpses of how it could be. The more we nurture this way of seeing, the more naturally we transform possibility into reality.

Different Ways of Seeing

To uncover the gap between reality and possibility, I rely on four distinct lenses.

Each reveals something unique, offering a new way to frame problems and uncover opportunities.

1. The Curious Child: Why are things the way they are?

This lens questions basic assumptions that others take for granted. By stripping away learned behaviors, it helps uncover opportunities hidden in plain sight.

• Example: Why are all notifications treated equally on smartphones? Could we rethink urgency and relevance in how they're delivered?

• Prompt Questions:

  • Why do we accept this as "just how it works"?

  • What if we challenged this core assumption?

  • Could there be a fundamentally different approach?

Try it: Pick a product or feature you use daily and question its most basic design choices. You’ll be surprised how many “that’s just how it works” moments can spark new ideas.

2. The Frustrated User: What’s getting in our way?

This lens treats friction as a signal. Every clunky or frustrating interaction points to an unmet need or opportunity for improvement.

• Example: At self-checkouts, weight detection errors and unclear prompts frustrate users. What if they could skip the process entirely and just walk out, with items automatically detected and charged?

• Prompt Questions:

  • Where do people pause or hesitate?

  • What makes this interaction feel unnatural?

  • Which parts of this experience require extra effort?

Try it: Notice your own moments of frustration with products. Instead of working around them on autopilot, write them down—they often cluster around valuable opportunity spaces.

3. The Observer: How do people really behave?

This lens highlights the gap between how systems are designed to work and how people actually use them. Real-life workarounds often reveal unexpected pain points or opportunities.

• Example: Commuters lifting their phones high for better signal highlight connectivity struggles in transit areas. This behavior points to a clear need for better infrastructure or signal-boosting tools.

• Prompt Questions:

  • What workarounds are people creating?

  • Which features are being used differently than intended?

  • What patterns emerge across different users?

Try it: Watch how people use everyday products. Each workaround is a clue to an unmet need, especially if the behavior repeats across users.

4. The Problem Solver: How might we bridge these worlds?

This lens synthesizes the insights from the other three to imagine transformative solutions that close the gap between reality and possibility.

• Example: Observing friction in finding parking spaces in cities led to products predicting open spaces with real-time data, transforming a frustrating process into an effortless experience.

• Prompt Questions:

  • How could we eliminate this friction entirely?

  • What would a more natural solution look like?

  • How might we turn this workaround into a feature?

Try it: Use your observations to imagine not just fixes but experiences that feel seamless and transformative. Focus on what could be, not just what's wrong now.

Share

From Daydreams to Reality

The most powerful product insights often come from reconnecting with our childhood imagination.

Take Apple’s AirTags. They transformed a universal frustration—losing things—into something almost magical: a digital game of hot and cold.

This wasn’t just clever product design. It was the result of seeing two realities at once: the adult problem of tracking belongings and the childlike joy of playful discovery. The best solutions emerge when we blend practicality with imagination to create something transformative.

The magic of great products lies in their ability to solve problems while sparking joy. It’s not just about what they do—it’s about how they make us feel.

Every interaction holds the seed of its future evolution. Every frustration is a clue to something better. But spotting these opportunities takes practice—learning to see what others miss, capturing ideas before they fade, and imagining how things could be.

And this practice doesn’t just lead to better products—it helps you tell better stories about them:

• For users: Capturing the moment they think, “Finally, something that truly understands my frustrations and can solve my problems, making life easier.”

• For teams: Revealing how small, thoughtful changes ripple outward, solving challenges they didn’t realize they could overcome.

• For markets: Painting a vision of the future your product enables—a world where moments of magic feel inevitable.

Great products don’t just solve problems—they tell stories about what’s possible. And those stories inspire action.

By using the four lenses—Curious Child, Frustrated User, Observer, Problem Solver—you can build a habit of uncovering hidden possibilities. And the more you nurture this way of seeing, the more naturally you’ll transform daydreams into reality.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

Early in my product career, I experienced something that fundamentally changed how I think about B2B products.

I was running demos constantly—different companies, different stakeholders, different priorities.

Young and eager, I believed I had a winning product. But what amazed me wasn’t just how diverse these organizations were—it was how differently each audience saw the product’s value:

• To users, it was an immediate win: "Wow, I can pull these insights for my presentations in seconds!"

• To managers, it triggered a broader calculation: "How can this help us streamline operations across the team?"

• To C-suite executives, it barely registered—until one key metric appeared: "Hold on, go back to that trend-line."

It became clear to me: B2B success isn’t about features—it’s about translating value effectively across layers of the organization.

I realized something crucial: I wasn’t just seeing different interpretations of the same value. I was watching value transform—or die—as it moved through organizational layers.

Each stakeholder didn’t just see different benefits—they needed entirely different stories to fight their own battles.

This pattern isn’t unique to my experience—it’s everywhere in B2B. And yet, most product teams miss it entirely.

The Value Translation Chain

If you’ve ever watched an enterprise deal stall, you know the frustration. On the surface, the reasons often sound simple:

• "They chose another vendor."

• "The budget got cut."

At first glance, these explanations might seem like the end of the story. But in my experience, they’re not the real reasons deals fall apart. They’re symptoms of a deeper failure: broken value translation.

What is value translation?
In B2B, the journey of your product’s value doesn’t stop with the first person who sees it. It needs to travel—across teams, up the chain of command, and into the hands of decision-makers. At every stage, your product’s value is reshaped and reinterpreted.

If this chain breaks at any point, deals stall, champions lose momentum, and your product’s story dies in the process.

The Role of Client-Side Champions

Your client-side champions—the people inside customer organizations who believe in your product—are your most critical allies. They are the ones who:

• For users: Share quick wins and advocate for the product.

• For managers: Build the case for broader adoption.

• For executives: Connect your product to big-picture goals.

Champions aren’t just "nice to have"—they’re essential. Yet most products don’t empower them with the right stories to succeed.

Here’s what really happens:

Your client-side champions lose internal battles they shouldn’t have lost. Not because your product wasn’t good enough, but because they didn’t have the right narrative ammunition to fight for it in their organization.

Where Value Dies: The Breaking Points

In B2B, value dies at predictable breaking points—each tied to the organizational layers your product must pass through:

1. The Individual-to-Team Break

• Users love the product but can’t quantify their wins.
  They may find it personally helpful, but without measurable outcomes, their enthusiasm doesn’t translate into broader adoption.

• Personal productivity gains get stuck at the individual level.
  Insights or efficiency improvements stay limited to single users, making it hard to show value at scale.

• Managers can’t justify a team-wide rollout based on isolated success stories.
  Without aggregated data or success metrics, managers lack the evidence they need to advocate for adoption across their teams.

2. The Team-to-Organization Break

• Team improvements don’t connect to departmental KPIs.
  Even if a team benefits from the product, those wins can feel disconnected from higher-level goals, making them less compelling.

• Middle management struggles to translate adoption metrics into business impact.
  Without clear alignment to broader objectives, adoption rates and usage stats may fail to resonate with leadership.

• Success stories stay trapped in silos, never reaching leadership.
  Wins at the team level often fail to make their way up the chain, stalling the narrative before it can gain executive buy-in.

3. The Organization-to-Strategy Break

• Operational wins fail to link to strategic initiatives.
  Day-to-day improvements may seem too tactical if they’re not explicitly tied to high-level goals like growth, innovation, or compliance.

• Executives can’t weave the product into the company’s broader narrative.
  Without a clear strategic fit, the product risks being seen as a "nice-to-have" rather than a critical tool for achieving the company’s vision.

• ROI calculations miss critical strategic value angles.
  Numbers may fail to capture long-term or intangible benefits, making the case for investment less compelling at the highest levels.

Share

Why Ugly Products Win

Seemingly "ugly" products often dominate the B2B market. They’re not winning despite their flaws—they’re winning because they’ve mastered value translation.

These products may have:

• A clunky UI that frustrates users.

• Features that lag behind competitors.

• Outdated technical architecture that developers dislike.

Yet, they win. Again and again.

Why? Because they understand something crucial:

In B2B, success isn’t just about what your product does—it’s about how it helps people prove their success to others.

• For Users: Not just "This makes me more effective" but "Here’s how I can prove my impact."

• For Managers: Not just "This makes my team more efficient" but "Here’s how I demonstrate organizational value."

• For Executives: Not just "This advances our strategic goals" but "Here’s how we showcase market leadership."

Building Translation Engines

Understanding the Value Translation Chain changes everything about how we build B2B products. It’s not enough to solve user problems—you need to design features that cascade value upward, connecting users to managers, and managers to executives.

Here’s how to embed these "translation engines" into your product's core:

1. Design for Multi-Level Impact

Don’t just build features. Build narrative enablers that resonate at every level of the organization by addressing specific needs and priorities:

• For Users: Surface insights that make their tasks easier and faster.

  • Example: "You identified key trends in half the time."

  • This gives users a clear, personal win, boosting their confidence and productivity by saving effort and time.

• For Managers: Aggregate individual insights into team-level reports.

  • Example: "Your team uncovered 15 actionable trends this month, driving key decisions faster."

  • Tangible results like these help managers advocate for broader adoption by showcasing measurable team impact.

• For Executives: Tie those insights to strategic initiatives.

  • Example: "Our compliance trend monitoring helped avoid regulatory risks, aligning with strategic goals for Q3."

  • By framing outcomes in terms of risk mitigation and strategic alignment, you position your product as essential to the company’s success.

The key is making value translation automatic, not an afterthought. By embedding these narratives into your product, you empower champions at every level to articulate its value effectively.

2. Master the Value Cascade

Every feature should tell a connected story—one that scales seamlessly across organizational levels. Design features with flexibility so the same core data can be reframed for the unique perspectives of users, managers, and executives:

• User Story: Speaks directly to the user’s need for speed and clarity in daily tasks.

  • Example: "I used this tool to identify the top compliance risks in seconds."

  • In a conversation with their manager, a compliance analyst highlights how the tool saves hours, turning a personal win into a team productivity boost.

• Manager Translation: Shows how individual actions scale into measurable team-wide improvements.

  • Example: "My team streamlined risk identification and reduced reporting delays by 50%."

  • The team lead demonstrates how automation has improved overall efficiency, enabling faster reporting to stakeholders.

• Executive Translation: Focuses on strategic outcomes that tie directly to KPIs and long-term goals.

  • Example: "We’ve enhanced compliance monitoring, avoiding potential penalties and building stakeholder trust."

  • The compliance officer shares these results with the board, showing how the tool mitigated legal risks and saved the company millions.

The same insight, tailored to different organizational lenses, creates a consistent yet flexible narrative that resonates at all levels. Your goal is to ensure each audience gets the version of the story they need to succeed.

3. Build Narrative Infrastructure

Success in B2B requires more than just features—it requires tools that actively tell your product’s story for you. Embed mechanisms into your product that enable champions at every level to communicate value effortlessly:

• Automated value capture at the user level: Automatically track and highlight user achievements, such as time saved, tasks completed, or insights delivered. These metrics make it easy for users to showcase their impact.

• Built-in translation mechanisms for middle management: Provide dashboards or reports that consolidate individual contributions into team-level insights, showing trends, impact metrics, and areas of improvement.

• Strategic dashboards for executives: Offer high-level summaries that tie performance metrics directly to strategic priorities like revenue growth, compliance, or competitive positioning.

Think of your product as a story-building platform:

• Users get tools to document their findings and communicate their wins.

• Managers receive synthesized insights to advocate for broader adoption.

• Executives gain strategic narratives that demonstrate measurable business impact, ensuring your product aligns with their vision.

By embedding narrative infrastructure, you make value translation seamless and scalable, empowering every champion to succeed without relying on external resources.

Share

Silent Success is Still Failure

The harsh truth: In B2B, silent success is still failure. Your product needs to actively enable its story to be told—and retold—at every organizational level.

→ The best features aren’t just powerful. They’re self-narrating.

The Bottom Line

Great features without great stories die in procurement. But average features with powerful narrative chains? They become enterprise standards.

Your job isn’t just to build the best product—it’s to build the product that helps your champions win their internal battles.

When planning features, ask yourself:

• How can we empower champions, not just improve features?

• How can we create stories that resonate organizationally, not just with users?

• How can we ensure product-narrative fit, not just product-market fit?

You’re not just building software. You’re creating the stories, tools, and resources your champions need to advocate for your product—and succeed at every level.

→ Make sure your champions have everything they need to win.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

Dark Patterns Detective is an interactive mini-game that teaches you how to spot manipulative design tricks online. It's fun, free, and takes less than 10 minutes to complete!

You know that moment when you're helping your parents with a website and you catch yourself saying "Oh, don't click that – it's trying to trick you"? That's exactly what inspired me to build it.

🎮 Try it out here for free: darkpatternsgame.productartistry.com

Video demo of one of the lessons in action:

After spending time as a product manager in the cyber risk space (and being a huge Don Norman fan), I've gotten pretty good at spotting these manipulative design patterns. But watching my parents navigate the web recently made me realize just how much of this knowledge I take for granted.

Instead of just writing about it, I thought: "Why not make something interactive that actually teaches people to spot these tricks?" It was also the perfect excuse to learn TypeScript properly – nothing beats building something real to level up your skills!

The game has 10 quick lessons that:

• Train your eye to catch manipulative design tricks

• Show you how these patterns mess with your brain

• Give you practical ways to avoid getting caught by them

What you'll learn:

• How to spot hidden costs before checkout

• Ways companies use FOMO to pressure you

• Tricks that make it hard to cancel subscriptions

• Common tactics that exploit your attention

• Practical defense strategies you can use daily

🎮 Play now: darkpatternsgame.productartistry.com

I've started many side projects before, but the accountability of writing this newsletter helped me see this one through to completion. I'm really proud of how it turned out and excited to share it with you all!

Would love to hear what you think (or of any bugs you find 🙃)! And since it's educational, feel free to share it with anyone who might benefit from it or just find it interesting.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

It’s easy to fall into the cycle of relentless iteration—polishing, refining, and optimizing—only to realize you’re stuck spinning your wheels.

The tweaks feel productive, the progress looks good on paper, but the deeper issue remains untouched: you’re solving the wrong problem.

I learned this the hard way during a product design phase that felt like running on a treadmill.

Every meeting brought new tweaks, every iteration seemed better than the last, but the results were hollow.

Our improvements only masked deeper issues. The more we refined, the clearer it became: We weren’t building forward—we were building sideways.

In this post, you’ll learn how to:

• Recognize the subtle signs that your solutions are masking deeper issues.

• Identify three patterns that reveal you might be solving the wrong problem.

• Use a practical framework to shift from surface-level fixes to meaningful breakthroughs.

When Solutions Create Problems

At first glance, everything seemed fine. The demos looked promising. Each iteration addressed feedback, resolved specific pain points, and improved individual workflows.

But as we dug deeper, cracks started to show:

• Changes that delighted some users confused others.

• Solutions that simplified one workflow made three others more complicated.

• Each improvement chipped away at the product’s overall coherence.

We weren’t moving forward—we were optimizing ourselves into a corner. Every change felt like progress, but the pieces no longer added up. We were investing resources into solutions that looked right on paper but didn’t hold together in practice.

Does this sound familiar?

These aren’t signs of poor execution. They’re signals that you’re solving the wrong problem.

Why We Miss the Signs

Recognizing these signals takes more than observation—it requires the courage to question what’s beneath the surface of our work.

Admitting we’re solving the wrong problem can feel uncomfortable. It forces us to confront difficult questions:

• What if we’ve misunderstood the problem from the start?

• What if everything we’ve built so far is based on flawed assumptions?

These questions are hard to face because they challenge the foundation of our work. Instead of addressing them, we often default to safer, familiar behaviors:

• Doubling down on iteration, hoping another round of tweaks will finally "fix it."

• Chasing the next wave of feedback, focusing on symptoms instead of stepping back to reassess the cause.

• Polishing features, masking systemic gaps with surface-level improvements.

The friction we feel—the gap between effort and results—isn’t a sign to push harder. It’s a signal to pause and look deeper.

I first encountered this misalignment during a project where our improvements kept canceling each other out.

Each iteration addressed a symptom, but the underlying issue remained unresolved. The problem wasn’t poor execution. It was our failure to address the real, deeper needs behind the feedback.

Share

The Hidden Patterns

Here are three common patterns that signal you're solving the wrong problem:

1. When "More" Makes Things Worse

• Are added features fragmenting the user experience?
  For example, does each new feature create more complexity, making it harder for users to navigate?

• Do increased options reduce clarity?
  Could simplifying choices make the solution more intuitive and effective?

• Is more polish revealing deeper cracks?
  For instance, does improving aesthetics highlight underlying issues with functionality or coherence?

💡 Insight: These patterns often indicate you’re addressing symptoms rather than tackling the root cause of the problem.

2. When "Better" Isn’t Progress

• Are improvements creating new edge cases?
  For example, does refining one flow introduce unintended complications elsewhere?

• Do clearer flows lead to more confusion?
  Are attempts to streamline making parts of the experience harder to understand?

• Is polish failing to reduce complexity?
  Are enhancements only making the system feel heavier instead of more intuitive?

💡 Insight: These signs suggest you might be perfecting the wrong solution instead of addressing the deeper issue.

3. When Scale Shows Truth

• Does what works for some users break for others?
  For example, are changes optimized for one segment at the expense of another?

• Are quick wins creating long-term debt?
  Do short-term fixes compromise your ability to scale effectively later?

• Are resources draining faster than progress builds?
  Is the effort required for improvement outpacing the benefits you’re seeing?

💡 Insight: This pattern reveals you may be optimizing for the wrong metrics or goals, creating misalignment as your solution grows.

Subscribe now

Finding Better Problems

The key isn’t to abandon iteration—it’s to recognize when incremental improvements are masking deeper issues.

When we chase feedback without direction, we risk building elegant solutions to the wrong problems. Here’s how to shift from friction to insight:

1. Notice the Tension

Friction often points to deeper issues that surface-level changes can’t fix. Look for areas where:

• Are simple changes creating unexpected complexity?
  For instance, has adding a minor feature led to cascading impacts that disrupt workflows or confuse users?

• Do solutions consistently demand more solutions?
  Are quick fixes resolving one issue only to introduce new edge cases that require further patches?

• Does anything feel unnecessarily complicated?
  Are workflows involving multiple steps that seem redundant or overly intricate?

💡 Insight: Tension is a signal, not a barrier. It points you to areas where the underlying problem is waiting to be uncovered.

2. Question Your Compass

It’s easy to lose sight of the bigger picture when focused on iteration. Step back to revisit the foundation of your efforts:

• What problem were we originally solving?
  For example, were you trying to streamline a process, only to inadvertently create something more complex?

• Has our target shifted without us realizing it?
  Teams often get swept into solving for recent feedback rather than the core issue.

• What assumptions are we carrying forward?
  Consider whether decisions from earlier stages are constraining today’s solutions.

💡 Insight: Reassessing your compass ensures you’re still heading in the right direction, not just moving faster in the wrong one.

3. Reframe the Problem

Sometimes the real breakthrough comes from redefining the problem entirely. Instead of asking, “How can we improve this?” consider:

• What if we’re solving the wrong level of the problem?
  For instance, are you refining a feature when the larger system needs redesigning?

• What would we build if we started fresh today?
  Thinking from a clean slate often highlights inefficiencies or unnecessary complexities.

• What different problem could unlock simplicity?
  For example, addressing a user’s core need might eliminate the need for certain features altogether.

💡 Insight: Reframing helps you see beyond incremental fixes and opens the door to transformative solutions.

Share

Final Thoughts: From Friction to Breakthroughs

True progress doesn’t come from adding more features, perfecting flows, or polishing endlessly. It comes from stepping back, reframing the problem, and building for clarity, simplicity, and coherence.

Breakthroughs aren’t hidden in the next round of tweaks—they’re revealed when you embrace the friction and ask the hard questions it uncovers.

→ This week, challenge yourself and your team to go deeper:

• Where are "improvements" creating unnecessary complexity?

• What assumptions are keeping us stuck in a cycle of iteration?

• Most importantly: What problem are we really solving?

The answers to these questions won’t just transform your product—they’ll redefine how you think, build, and solve problems, unlocking possibilities you hadn’t imagined.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

"We’re going to use the black hole’s gravity to slingshot us into another galaxy. It’s about as close as we can get to a shortcut."
— Cooper, Interstellar (2014)

The Hidden Physics of Market Breakthroughs

Most startups try to escape market forces. The smartest ones use them as fuel.

The most powerful competitive force isn't what you think. It's not your competitor's features, funding, or market share—it's their gravitational pull.

This invisible force shapes how users think, choose, and act. Most founders see it as their biggest barrier to entry.

But here's the counterintuitive truth: market leaders don't just create obstacles—they create stored energy waiting to be harnessed.

Their gravitational force, meant to lock customers in, becomes the very power that can launch you beyond them.

When you understand market physics, everything changes:

• What looks like an impenetrable wall becomes a potential slingshot

• Every constraint they create becomes potential energy

• Every locked-in pattern becomes a launch point

• Every blind spot becomes an acceleration opportunity

This is the competitive slingshot effect. Instead of fighting market leader gravity, breakthrough companies transform it into momentum. The effect works in three powerful ways:

1. Gravity Becomes Fuel: Their market pull becomes your acceleration force

2. Constraints Become Launch Points: Their limitations become your opportunities

3. Mass Becomes Momentum: Their size amplifies your breakthrough potential

Let's decode how this works through the three laws of market physics—and how you can harness this force to break through.

The Three Laws of Market Physics

Let's explore how these laws work in practice through Figma's journey. They turned Adobe's massive gravitational force into breakthrough momentum, perfectly illuminating the three laws that govern market physics.

1. Gravitational Lock-in

In 2012, Adobe's gravitational pull defined how design worked. They had spent decades establishing the rules of professional design best practice:

What Adobe Made "Normal":

• Creative work required expensive desktop software

• Files were the only way to share and collaborate

• Version control meant endless naming conventions

• Real design happened in individual, offline tools

But Figma saw something different. Where others saw barriers, they saw stored energy waiting to be released:

Where Energy Built Up:

• Desktop software meant painful installation and updates

• File-based workflows created collaboration friction

• Version control spawned endless confusion

• Individual focus left team needs unaddressed

The deeper Adobe's gravity well became, the more potential energy it created for transformation. Each "that's just how design works" assumption became a launch point.

2. Orbital Positioning

Figma didn't try to break free immediately. Instead, they found the perfect orbit around Adobe's gravity well—close enough to draft off decades of market education but far enough to reimagine how design should work.

Their orbital position was precise:

• Close enough that designers understood what Figma was

• Far enough to create an entirely new collaborative experience

• Just right to accumulate maximum energy from Adobe's constraints

From this position, they built momentum by:

• Making the browser their foundation when Adobe couldn't

• Turning version control pain into real-time collaboration

• Converting file friction into instant sharing

• Building where Adobe's desktop DNA prevented them from following

Each limitation in Adobe's system became a point of acceleration for Figma.

3. The Slingshot Moment

Figma waited years for the perfect moment to convert Adobe's gravity into breakthrough momentum. Three forces aligned:

1. Technology enabled their vision:

   • WebGL made browser performance possible

   • Cloud infrastructure matured

   • Real-time collaboration became viable

2. Market frustration peaked:

   • Remote work exposed file-sharing pain

   • Design systems needed team solutions

   • Version control chaos reached breaking point

3. Their solution reached escape velocity:

   • Browser performance matched desktop

   • Team features created viral growth

   • Network effects began compounding

When they hit this moment, Adobe's gravity became their accelerant:

• Desktop friction made browser-based instant access compelling

• File pain made real-time collaboration irresistible

• Individual focus highlighted team-first value

They didn't just escape Adobe's gravity—they used it to slingshot beyond anyone's expectations. But the most powerful validation of their strategy was yet to come.

The Gravity Returns

The ultimate validation of this physics came in that $20 billion acquisition attempt. Adobe, who had created the gravity well that Figma used for their slingshot, effectively admitted two things:

1. They couldn't pull Figma back into their orbit

2. Figma had reached escape velocity with their own gravity

The price tag wasn't just about Figma's revenue or technology. It represented the energy Adobe had unknowingly stored in their constraints—energy Figma had converted into breakthrough momentum.

Even more telling? When regulators blocked the acquisition, it confirmed that Figma hadn't just escaped Adobe's gravity—they'd created their own gravitational force strong enough to threaten Adobe's market position.

This is the power of the slingshot effect: Market leader gravity doesn't just create resistance—it creates potential energy. The stronger their gravitational pull, the more momentum available for your breakthrough.

Sometimes so much momentum that the very force that created the gravity well tries to buy back the energy they gave away.

Share

Building Your Slingshot Strategy

Now that we understand the three laws of market physics, let's explore how to harness them strategically. Each stage presents unique questions that can guide us in converting market leader gravity into breakthrough momentum:

1. Map the Gravity Well

Converting constraints into potential energy:

• Where do users feel most locked in? Focus on identifying behaviors that feel unchangeable but create significant friction.

• Which 'normal' workflows cause frustration? Look for accepted patterns that limit possibility and create energy for transformation.

• What constraints seem unavoidable? Identify limitations that are treated as unchangeable facts of the market.

2. Position for Launch

Finding the perfect orbital trajectory:

• Which patterns should you keep vs. reimagine? Determine where to draft off market education and where to break from convention.

• Where is the leader's gravity weakest? Identify adjacent spaces where transformation is possible without direct confrontation.

• What prevents them from following? Find structural limitations in their core DNA that create protected space for innovation.

3. Time Your Slingshot

Converting stored energy into breakthrough momentum:

• Which technology barriers are disappearing? Watch for enabling technologies that change what's possible.

• When will user frustration peak? Identify moments when existing constraints become most visible and painful.

• What signals sustainable momentum? Look for compounding effects that can accelerate your escape velocity.

Moving from constraint to breakthrough, these questions help us convert market leader gravity into forward momentum.

Share

Final Thoughts: Breaking Through

The strongest market positions don't come from fighting leader gravity—they come from turning it into breakthrough force.

Every constraint they create is potential energy waiting to be released. Every pattern they lock in is a launch point waiting to be discovered.

The question isn't whether you can break free from a market leader's gravity. It's whether you can turn their greatest strength into the force that propels you beyond them.

Remember: The stronger their gravitational pull, the more energy available for your slingshot. You just need to know how to convert it.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

"First we shape our tools, thereafter our tools shape us."
— John Culkin

The Three-Wave Impact Pattern

When a product succeeds at scale, its impact goes far beyond solving immediate problems.

Every successful product creates waves of impact—distinct phases of influence that deepen and evolve over time.

These waves don’t happen randomly. They follow a predictable pattern, each stage becoming more powerful and ingrained as the product integrates into everyday life.

By understanding these three waves, we can create with greater intention, guiding a product’s journey from practical solution to cultural force.

Let's explore this pattern through Apple’s AirPods—a product that began as a solution to tangled wires but has since transformed how we experience the world around us:

Wave 1: Solution → Adoption

Every product’s impact journey begins with clear intent: solving a specific problem. This is the realm of conscious design, where solutions open new possibilities.

For AirPods, the first wave involved:

• Eliminating tangled headphone wires

• Enabling seamless device pairing

• Delivering high-quality wireless audio

This wave is straightforward—it’s what users buy, what we measure, what we market. But when a solution achieves this level of utility at scale, it sets deeper transformations in motion.

Wave 2: Adoption → Behavior

As a product weaves itself into everyday routines, it begins reshaping behaviors in ways its creators may not have anticipated.

This wave isn’t about features or metrics—it’s about how the product subtly transforms real-world habits, interactions, and social norms until new patterns become second nature.

For AirPods, the second wave brought:

• The normalization of wearing headphones casually throughout daily life

• A shift toward being "partially tuned out" in social settings

• A new social signal of unavailability—AirPods in, approach with caution

These shifts weren’t explicitly designed—they emerged naturally as the product embedded itself into diverse contexts.

What began as convenience became a widespread social language, setting the stage for even deeper transformation.

Wave 3: Behavior → Culture

In this final wave, products move from influencing individual behavior to reshaping collective perception.

Products don’t just change what people do—they alter how people interpret and interact with their world.

For AirPods, the third wave redefined:

• The boundary between online and offline presence

• Ambient audio as a constant part of human experience

• Social spaces as hybrid environments where personal and digital boundaries blur

Here, products become more than tools—they evolve into cultural forces that transform multiple aspects of how we experience ourselves, others, and the world around us.

Share

Building with Wave Awareness

Now that we understand the three waves of product impact, let’s explore how to design with them intentionally.

Each wave presents unique questions that can guide us in shaping a product’s transformation:

Wave 1: Design → Impact

Building for direct utility and scalable transformation:

• What specific problem, when solved well, unlocks new possibilities? Focus on creating solutions that go beyond utility, opening doors for transformative behaviors.

• How will the solution scale naturally? Design with scalability in mind so that core features feel inevitable and self-sustaining as adoption grows.

• What enables breakthrough adoption? Remove friction from critical touchpoints to make the product easy and enjoyable to adopt.

Wave 2: Impact → Evolution

Anticipating behavioral and social transformation:

• Which behaviors might emerge at scale? Consider how daily routines and usage patterns could shift as the product embeds itself into users' lives.

• What social dynamics could transform? Design with an eye on how collective behaviors may evolve, creating new norms around the product.

• Which existing patterns will shift? Anticipate which established norms or habits might be disrupted or redefined as the product scales.

Wave 3: Evolution → Transformation

Shaping cultural impact with intention:

• What worldview are we enabling? Define the broader cultural message or perspective that the product represents.

• Which reality are we making possible? Consider the long-term effects the product may have on people’s interactions and worldviews.

• What cultural currents are we amplifying? Be mindful of the norms and values your product promotes, designing for the kind of world you want to create.

Moving from utility to culture, these questions help us anticipate and guide a product’s evolution.

By considering each wave with intention, we can amplify positive transformations while mitigating potential downsides.

Ultimately, the question isn’t whether your product will transform culture—it’s whether you’ll shape that transformation by design.

Share

Final Thoughts: The Power of Wave Awareness

Every product decision ripples outward, moving from utility through behavior to culture.

Understanding these waves transforms us from makers to shapers—going beyond simply hoping for impact to intentionally designing for transformation.

Solution → Impact → Culture

This cascade brings both opportunity and responsibility:

• The opportunity to shape culture systematically, rather than accidentally.

• The responsibility to create tomorrow’s reality with deliberate intention.

Now that you see the waves, you can navigate them.
Make your impact intentional.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

"What is now proved was once only imagined."
— William Blake

The difference between good ideas and great breakthroughs isn't creativity. It's seeing the invisible forces that shape everything.

Years after engineering school, I finally understood what we were actually learning. While my classmates and I were busy memorizing formulas and calculating loads, we were unconsciously absorbing something far more valuable: a way of seeing the world that would transform how we create.

As my journey took me from engineering to risk modeling to product building and now writing, these technical frameworks rewired my creative process. What began as dry engineering concepts evolved into powerful mental models for understanding any complex system—sparking countless "I never thought about it that way" moments from others.

While not everyone needs to be an engineer, every creator can benefit from the systematic ways engineers see the world. These 5 mental models don't constrain creativity—they amplify it by bridging the gap between systematic thinking and creative breakthroughs.

1. The Power of Invisible Forces

The first lesson in structural engineering isn't about what you can see—it's about what you can't. While most people focus on a building's visible elements—its soaring beams and striking walls—engineers obsess over the invisible forces that could bring it all down: stress distributions rippling through steel, thermal loads warping structures, wind patterns testing every weakness.

This lens transforms how you see every creative endeavor:

→ In Products:

• Silent user frustrations that trigger sudden abandonment

• Hidden technical debt that paralyzes innovation

• Subtle interaction patterns that slowly erode engagement

→ In Business:

• Invisible cultural currents that fracture teams

• Hidden market forces that reshape industries

• Subtle competitive pressures that erode advantages

→ In Creative Work:

• Unconscious biases that limit our creative range

• Hidden assumptions that constrain our solutions

• Subtle mental blocks that kill breakthrough ideas

This might be engineering's greatest gift to creativity: success isn't about perfecting what's visible—it's about mastering what's invisible.

The Creative Shift: Stop asking "How do I make this better?" and start asking "What invisible forces am I ignoring?" The most powerful opportunities for innovation aren't in what's obvious—they're in the subtle patterns and hidden forces that shape everything we build.

2. The Art of Probabilistic Thinking

Most creators deal in possibilities—engineers deal in probabilities. This mindset shift crystallized for me while modeling catastrophe risks in the insurance industry, where binary thinking about success and failure transformed into a rich landscape of probabilities and patterns.

Engineering teaches you to replace "Could this work?" with "Under what conditions will this thrive?" This subtle shift changes everything about how you navigate uncertainty..

→ The Creator's Default:

• Chasing every possible idea

• Trying to prevent all failures

• Seeking the perfect solution

→ The Engineer's Way:

• Mapping success probabilities

• Understanding failure patterns

• Optimizing for likely outcomes

When you embrace probabilistic thinking, your entire creative process transforms. Instead of asking "Will users like this?", you start exploring "Which user segments will find the deepest value?" Rather than fearing failure, you begin mapping patterns that predict success. You stop hunting for guaranteed wins and start building portfolios of calculated risks, focusing your energy where probability meets impact.

The Creative Shift: Your goal isn't to eliminate uncertainty—it's to harness it. Stop thinking in binary outcomes of success and failure. Start thinking in distributions of possibility, where every creation is an experiment in probability.

Share

3. The Creative Power of Constraints

Here's the paradox engineering taught me: constraints don't limit creativity—they ignite it. Every breakthrough design begins not with unlimited possibilities, but with clear constraints: budgets, materials, physics, time. These aren't restrictions to fight against—they're the fuel that drives innovation.

→ Constraints Create Power By:

• Breaking the paralysis of infinite options

• Forcing innovative solutions

• Challenging comfortable assumptions

→ Constraints Provide Direction Through:

• Defining clear solution spaces

• Creating objective success criteria

• Enabling faster decisions

When you embrace constraints, the impossible becomes possible. Time limits prevent perfectionist paralysis. Technical restrictions spark creative workarounds. Resource constraints drive elegance through simplicity. What looks like limitation becomes liberation—a focused canvas for innovation.

The Creative Shift: Stop fighting your constraints. Start using them as creative fuel. The most innovative solutions emerge not from unlimited freedom, but from the creative tension of well-defined boundaries.

4. The Beauty of Feasible Solutions

Engineers learn a truth that many creators resist: a perfect design that exists only in theory changes nothing. A "good enough" solution that exists in reality changes everything. This isn't settling for mediocrity—it's understanding that impact requires existence.

→ Two Paths to Impact:

• The Perfect Solution: Forever in development, never touching reality

• The Feasible Solution: Imperfect, but creating real value today

→ Reality Rewards Action:

• A launched MVP reveals true user needs

• An imperfect feature evolves through usage

• A simple solution solves real problems now

When you embrace feasibility, creativity becomes momentum. Published work reaches real audiences. Shipped features generate actual feedback. Each "good enough" solution builds the foundation for something better. Perfect becomes the enemy of possible—and possible is where impact happens.

The Creative Shift: Stop pursuing theoretical perfection. Start building real-world impact. True elegance emerges not from perfect planning, but from the dance between idea and implementation.

Subscribe now

5. The Echo of Early Decisions

In structural engineering, foundation choices ripple through everything that follows. Changes that would be simple at ground level become exponentially more complex as you build higher. This principle reveals a profound truth about creative work: some decisions cast longer shadows than others.

→ Decisions That Echo:

• Core architecture shapes all future possibilities

• Initial principles guide every choice that follows

• Early patterns become permanent habits

→ Areas of Impact:

• Foundation Choices: Core architecture, key technologies, fundamental direction

• Pattern Decisions: Workflows, processes, methodologies

• Identity Choices: Values, voice, guiding philosophy

When you understand the echo of early decisions, you approach beginnings differently. You spend more time on foundational choices, knowing they'll shape everything that follows. You carefully consider early patterns, recognizing they'll become your defaults. You protect core principles, aware they'll guide countless future decisions.

The Creative Shift: Stop treating all decisions equally. Start protecting the choices that will echo through your entire creative journey. The most powerful creators don't just make good decisions—they recognize which decisions will cast the longest shadows.

Share

Final Takeaway: The Bridge Between System and Soul

Looking back, I realize engineering school wasn't teaching me about buildings at all. It was teaching me how to see the invisible architecture behind everything we create.

These mental models work whether you're building bridges, products, teams, or art because they reveal the fundamental patterns that shape how things come together—and how they fall apart.

→ The Engineer's Creative Path:

• Map the Invisible: What unseen forces shape your creation?

• Think in Probabilities: Where should you focus for maximum impact?

• Embrace Constraints: How can limitations fuel your solutions?

• Ship the Feasible: What's the smallest version that creates value?

• Protect Foundations: Which early decisions will echo forward?

This framework isn't about making creativity mechanical—it's about giving your creative spirit a stronger foundation to build upon. It's about finding that sweet spot where systematic thinking amplifies rather than constrains your artistic vision.

The true power of engineering thinking isn't in making things perfect—it's in making the remarkable possible.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

“The first step is to establish that something is possible; then probability will occur.”
— Elon Musk

Most innovation frameworks optimize within existing constraints. But what if the constraints themselves are the problem? Elon Musk's approach at Tesla and SpaceX reveals a systematic method for breakthrough innovation by questioning everything—including the questions themselves.

→ The real power of Musk's framework?
It forces you to think in first principles when everyone else is stuck in best practices.

When This Algorithm Matters Most

The power of this framework lies not in any single step but in the sequence. Each step amplifies the next, creating exponential improvement over time:

1. Questioning enables bold deletion.

2. Deletion creates space for simplification.

3. Simplification accelerates learning.

4. Faster learning cycles refine automation.

Before diving into the specifics, consider where this framework shines. It’s particularly powerful in markets with rigid practices and high technical complexity, where challenging assumptions can unlock new possibilities.

This approach is ideal when cost reduction could transform accessibility or create entire markets. However, it’s less effective if you’re facing immovable regulatory constraints or when speed to market is the primary goal.

1. Question Every Requirement Through First Principles

Requirements often pose as facts, but they're often just calcified assumptions layered over time. The first step is to break down each “must-have” and analyze it at its core. By tracing each requirement back to first principles, you open the door to innovation and ground-up rethinking of solutions.

→ Key Questions to Ask:

• What’s the true cost of accepting this constraint?

• How has technology evolved since this requirement was established?

• If starting from scratch today, would this requirement even exist?

• What would it take to make this requirement obsolete?

Applying First Principles at Tesla and SpaceX: These questions have led to paradigm-shifting changes in both companies, challenging long-held industry norms.

⚡️ Tesla Example: The Dealership Challenge

• Traditional Requirement: "Cars must be sold through dealerships."

• First Principle Question: "What’s the core goal of car distribution?"

• Solution: Direct-to-consumer sales

• Result: Higher customer satisfaction and faster feedback loop from market.

🚀 SpaceX Example: The Reusable Rocket Revolution

• Traditional Requirement: "Rockets are expendable."

• First Principle Question: "Why can’t rockets land and be re-used like planes?"

• Solution: SpaceX Reusable Launch System Development Program

• Result: 90% cost reduction per launch.

2. Delete Ruthlessly

Strategic deletion isn’t just about efficiency—it’s about systematically removing anything that doesn’t directly serve the mission. Every component, feature, or process should justify its existence.

→ Key Questions to Ask:

• What would break if we removed this entirely?

• Which processes exist purely due to history?

• How much overhead does each component actually create?

• What could we accomplish if this limitation didn't exist?

Applying Strategic Deletion at Tesla and SpaceX: Through these questions, Musk’s teams have eliminated unnecessary costs, freed up resources, and paved the way for more agile operations.

⚡️ Tesla Example: Service Center Transformation

• Traditional Model: Physical service center network.

• Deleted Element: Fixed service locations.

• Solution: Mobile service fleet + Over-the-Air (OTA) updates

• Result: Over 65% of service jobs handled by mobile fleet, leading to higher customer satisfaction and improved operational efficiency.

🚀 SpaceX Example: Supply Chain Revolution

• Traditional Model: Thousands of aerospace suppliers.

• Deleted Element: External dependency for key components.

• Solution: 85% vertical integration

• Result: Faster development and huge cost reductions on key components.

Subscribe now

3. Simplify with Intent

Simplification targets complexity at its root. Musk’s teams simplify with intention, ensuring each component serves multiple functions while minimizing dependencies.

→ Key Questions to Ask:

• Can system dependencies be reduced or eliminated?

• Are there overlapping functions that could be combined?

• What’s the complexity-to-benefit ratio?

• Can we rapidly prototype simplified alternatives?

Applying Simplification at Tesla and SpaceX: By focusing on essential components, Musk’s companies have streamlined production, increased reliability, reduced costs, and improved product quality.

⚡️ Tesla Example: Interior Design Revolution

• Traditional Approach: Multiple displays, buttons, controls.

• Simplified Solution: Single touchscreen interface.

• Result: Significant reduction in physical components, lower manufacturing costs.

🚀 SpaceX Example: Raptor Engine Design

• Traditional Approach: Multiple fuel types and systems.

• Simplified Solution: Single-fuel methalox engine.

• Result: Fewer engine components, and higher reliability.

4. Accelerate Learning Cycles

Speed compounds learning. By iterating faster, Musk’s teams uncover breakthrough opportunities more frequently and with greater insight.

→ Key Questions to Ask:

• What's the longest gap in our feedback loop?

• Which decisions could we automate or decentralize?

• How could we halve our iteration time?

• What prevents us from learning faster?

Applying Accelerated Learning at Tesla and SpaceX: Faster feedback loops have allowed these companies to adapt rapidly, creating products that are constantly evolving based on real-time insights.

⚡️ Tesla Example: Over-the-Air Evolution

• Traditional Cycle: Annual model updates.

• Accelerated Approach: Rolling software updates.

• → Result: Consistent improvements to product after delivery.

🚀 SpaceX Example: Rapid Prototyping Program

• Traditional Cycle: Years between iterations.

• Accelerated Approach: Monthly Starship prototypes for testing.

• Result: Significantly faster development cycle.

5. Automate Strategically

Automation can multiply the effects of efficient processes but magnifies flaws in inefficient ones. The key is to automate only after achieving stability and simplicity.

→ Key Questions to Ask:

• Which processes are stable enough to automate?

• What metrics would prove automation success?

• How can automation enhance learning speed?

• Which manual processes create the most risk?

Applying Strategic Automation at Tesla and SpaceX: With stable, simplified processes in place, automation allows these companies to scale operations more efficiently and maintain high output with less manual oversight.

⚡️ Tesla Example: Gigafactory Automation

• Traditional Approach: Manual assembly lines.

• Automated Solution: Custom robotics.

• Result: Significantly higher output per square foot.

🚀 SpaceX Example: Launch Operations

• Traditional Approach: Large ground crews.

• Automated Solution: Autonomous ground systems.

• Result: Reduction in required launch personnel.

Share

When to Use This Framework

✅ Best for:

• Markets with entrenched practices: Industries that have operated under the same assumptions for decades, like automotive or aerospace, can benefit most from this framework by challenging deep-seated norms.

• Products with high technical complexity: Complex, engineering-driven products where cost, efficiency, and scalability are crucial—think of areas like electric vehicles, spacecraft, or advanced manufacturing.

• Scenarios where cost reduction opens new markets: When significant cost reduction can unlock new customers or applications, this framework helps achieve breakthrough affordability, making innovative products accessible at scale.

❌ Avoid When:

• Regulatory constraints are truly immovable: If regulations form a hard boundary (e.g., certain financial or healthcare standards), then working within, rather than challenging, these constraints might be more effective.

• Speed to market is critical: For products needing a rapid launch, the iteration time required to apply this framework could be prohibitive. Prioritize lean, quick-to-implement strategies in these cases.

• Resources for fundamental redesign are unavailable: Applying this approach often requires significant investment in R&D, infrastructure, or engineering talent. If resources are stretched thin, start with more targeted process optimizations.

→ 🧠 Remember: The goal isn’t disruption for its own sake—it’s about finding the shortest, most effective path to deliver maximum value and break free from legacy constraints. Begin with smaller processes, measure each step, and scale up what delivers results.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

Still here? I’d appreciate you taking a second to answer this quick poll for feedback:

"First, earning power went from physical to digital. Now assets and security are going from physical to digital." – Naval Ravikant

1. Introduction: The New Digital Real Estate

Look at any major city's property prices from the 1960s and you'll find stories that sound impossible today. In the US, while median incomes have risen just 29%, rents have risen 72%, and house prices have soared 121% nationally, with places like San Francisco seeing a staggering 531% increase. Our parents' generation could buy property on a single income.

But while we've watched physical property slip out of reach, a new frontier of ownership has emerged. Not in real estate, but in digital real estate. The tools, infrastructure, and opportunities that were once controlled by tech giants are becoming accessible to individuals. Just as property created generational wealth in the physical world, owned digital platforms are becoming the assets of our era.

2. The Era of Digital Sharecropping Is Ending

We became digital sharecroppers through the attention economy without realizing it. Every piece of content we create pays rent to platforms we don't own and we bear a risk due to information asymmetry—platforms hold all the control over visibility and algorithms while we remain in the dark.

• That 100,000-follower Twitter account you built?
  Gone overnight when Elon changed the verification system and engagement algorithms post-acquisition. Years of community building, erased by a business decision out of your control.

• Your Instagram business reaching millions?
  Meta cuts your organic reach by up to 90%, then asked you to pay for the same audience you built. Your followers are their assets, your content their collateral.

• That YouTube channel driving your revenue?
  One content policy update, one mysterious "algorithm change," and your viewership drops 70%. Six figures of annual income becomes minimum wage overnight.

Each platform pivot is a lease termination. Each algorithm update is a rent hike. While we celebrated hitting follower milestones, we were really building equity for our digital landlords. They own the land. They own the distribution. They own the relationships we thought we were building.

3. The Great Digital Migration Has Begun

The attention economy that turned us into renters is showing structural damage:

• Ad costs have surged by 61-185% year over year, depending on the platform.

• Organic reach has plummeted to single-digit percentages

• Users are suffering from content fatigue

• Trust in algorithmic feeds is crumbling

But here's what's fascinating: as public platforms falter, private spaces are thriving.

• Newsletter open rates significantly outperform social engagement

• Private communities show higher retention than public platforms

• Direct relationships are becoming more valuable than follower counts

This isn't a market crash—it's a mass migration. The cost to build your own platform is now less than a year's worth of social media advertising. Community tools have become sophisticated and accessible. Direct monetization options have exploded.

Subscribe now

4. From Real Estate Agents to Architects

The first wave of digital creators were essentially platform agents – experts at showing and selling space on someone else's property. Like real estate agents working purely on commission, they mastered the art of the platform game: optimizing for algorithms, chasing trends, and monetizing through sponsorships and affiliate links. They knew how to drive traffic, but they were building wealth for their platform landlords.

Today's creators are becoming architects of their own platforms. The technical barriers that once forced creators to build on existing platforms have crumbled:

• Custom payment systems that once required months of development now launch in minutes

• Community platforms that needed engineering teams can be built by individuals

• Marketing tools that demanded technical expertise now run on visual interfaces

• Data analytics that cost thousands are available out of the box

• AI enabling scalable and high-quality communication and automation

But the real shift isn't just in the tools – it's in the mindset. Instead of mastering temporary platform tactics, digital architects build systems that compound in value. Rather than chasing followers, they're building assets. Where others see content treadmills, they're designing scalable systems.

5. The Product Builder's Advantage

While most creators are still learning to be digital real estate agents, product-minded people have been quietly mastering the art of digital architecture. This mastery comes from five core advantages that product thinking brings to building digital assets:

1. Systems Thinking: Where creators see content calendars, product people see user journey maps. We design scalable systems that work even when we're not actively manning the construction site.

2. User Psychology: Platform algorithms once handled retention for us. On owned property, you need to engineer your own engagement mechanisms. We build spaces people want to return to.

3. Data Architecture: Your owned platform isn't just a content repository—it's a data generation engine. Just as property developers understand location analytics, we build funnels that generate actionable insights.

4. Experience Design: The difference between a house and a home is in the details. We create intuitive navigation patterns and seamless user flows that retain attention without platform-aided discovery.

5. Technical Foundation: Smart property developers know when to hire specialists and when to handle things themselves. We evaluate tools, make build-vs-buy decisions, and construct reliable technical stacks that scale fit-for-purpose.

Subscribe now

6. Building Property That Appreciates

Here's where product thinking creates an unfair advantage: we can actively accelerate the appreciation of our digital property. Every system improvement compounds. Every feature launch builds value. Every audience interaction strengthens the foundation.

When you own your digital property, you're building infrastructure:

• Your platform becomes an appreciating asset, not a rent payment

• Your audience relationships are direct, not mediated by algorithms

• Your data provides compound insights, not just fleeting metrics

• Your content builds lasting value, not temporary engagement

This infrastructure approach transforms your digital presence from a series of posts into a valuable property portfolio. Each piece reinforces the others, creating a network effect that can’t be replicated on rented platforms.

7. The Investment Opportunity of a Generation

Today's digital ownership tools are like the affordable lots in emerging neighborhoods of the 1970s. The initial investment isn't primarily financial—it's the courage to build on your own land rather than rent on someone else's.

The pioneers of this digital land rush aren't waiting for perfect conditions. Instead, they're taking strategic steps that compound over time:

• Converting social audiences into owned email lists

• Transforming content workflows into productized services

• Building community platforms that others can build upon

• Creating digital assets that appreciate without platform dependencies

These are foundational moves to claim your place in the digital property market before it matures.

Share

8. Your Next Move

The question isn't whether this migration will happen—it's whether you'll stake your claim now or wait until the prime digital real estate has been claimed.

Your path to digital property ownership starts with three concrete steps:

1. Choose Your Foundation: Pick one platform you'll fully own (website, newsletter, or community)

2. Build Your Asset: Convert one piece of platform content into an owned asset

3. Design Your System: Create one retention mechanism that doesn't depend on algorithms

Today's digital frontier is like those 'impossible' sounding real estate stories you may have heard from your grandparents—except this time, you're standing in the right decade, looking at empty lots, with the tools to build in your hands.

Subscribe now

Thanks for reading!—Found value in this? Three ways to help:

1. Like, Comment, and Share—Help increase the reach of these ideas

2. Subscribe for free—Join our community of makers

3. Become a paid subscriber—Support this creative journey

Keep Iterating,
—Rohan

→ Connect with me on LinkedIn, Bluesky, Threads, or X.

Still here? I’d appreciate you taking a second to answer this quick poll for feedback: