Your Product Backlog Is About to Be Infinite

The Scarcity Shift: When almost any idea can become a working prototype in a weekend, how do you decide what deserves a place on your roadmap?

In June 2026, Lovable reported that people were creating one million new projects a week on its platform.

Can you imagine? One million, every week!

While these applications weren’t necessarily “finished”, they included websites, internal tools, prototypes and early-stage software projects. But that's what makes this number interesting. An enormous amount of software is being created by people who, until recently, might never have attempted to build it themselves.

I think we're about to see the consequences inside product organizations, particularly in one familiar place: the product backlog.

In our last post, we explored why engineering attention is becoming increasingly scarce. Now consider what happens when the number of ideas competing for that attention becomes almost limitless.

The backlog was never really a to-do list

Every product leader knows the open secret about product backlogs. The top of the list gets built, and the bottom is where ideas go to quietly retire.

For a long time, engineering capacity drove those decisions.

A feature that needed a team of engineers for an entire quarter had to justify the investment, and plenty of ideas never made it past that conversation. "We don't have capacity right now" might have been one of the most useful sentences in product management. It was polite, usually true, and often ended the discussion.

AI is taking that sentence away.

Ideas that seemed too expensive a year ago can now be prototyped in a weekend. A customer success manager builds a version of the report customers keep requesting. A sales engineer creates a working demo for a prospect. Someone from leadership sees an internal prototype and asks why it isn't already on the roadmap.

These experiments are useful and we should encourage them, but they introduce a problem that traditional backlogs weren't really designed to handle.

We're no longer dealing only with feature requests. Increasingly, we're dealing with working prototypes that somebody wants us to ship.

And that's a very different conversation.

When a prototype becomes a promise

There's a subtle difference between receiving a feature request and being shown a working version of that feature.

The request starts a conversation about whether something is worth building, and the demo of a working version can make that conversation feel like it's already over.

Why? Because someone has proven the idea is technically possible. And if the sales team sees an opportunity, they’ll probably show it to the customer to get them excited. When that happens, the product team has to explain why the feature shouldn't ship.

I've seen firsthand how difficult those conversations can be even when everyone agrees engineering capacity is limited. Imagine how much harder they become when the response is, "But we already vibecoded bits of it."

The trouble is that a prototype answers only one question: can we make this work?

It tells us very little about whether enough customers need it, whether it belongs in the product, or what it will take to support it over the next three years. A weekend prototype might take months to make production-ready. Even if it doesn't, someone will still have to own it once customers start relying on it.

The easier it becomes to build a prototype, the more careful we need to be about turning it into a product commitment.

Why prioritization needs a new first step

Most product teams already have a framework for sorting through competing ideas.

Take Intercom's RICE model, which scores opportunities using Reach, Impact, Confidence, and Effort. It's a useful approach, and if AI genuinely makes something cheaper to deliver, its score should improve. That's how the framework is supposed to work.

The problem is what happens before an idea gets scored.

A working prototype can make the effort look deceptively small. The initial build is visible, while the longer-term commitment is much harder to estimate.

Consider a reporting feature that takes two days to prototype. Its effort estimate might look attractive until you account for production security, customer permissions, real-time performance, documentation, ongoing support, and the inevitable requests for changes.

RICE considers the effort required from product, design, and engineering. But it isn't designed to answer every question about strategic ownership or years of maintenance, which requires a different conversation.

With AI bringing so many more ideas into consideration, I'd argue that conversation needs to happen much earlier: before asking where something belongs on the roadmap, we should ask whether it belongs there at all.

A better filter for an infinite product backlog

Now, I’m not saying to throw out your prioritization frameworks, but I'd suggest putting a few checks in front of it:

1. Keep experiments separate from product commitments.

Let people prototype freely. There's real value in making it easier to test ideas, but a prototype shouldn't automatically become a backlog item.

Give experiments their own queue, with a clear question they're trying to answer and a date to review what was learned. Some will inevitably graduate to the product backlog, and others can be archived without anyone feeling the work was wasted. An experiment that tells you what not to build has done its job.

2. Ask for evidence of customer value.

A good demo creates initial excitement. That's useful, but excitement isn't the same as sustained demand. Who needs this? How often? What problem does it solve? Have customers shown they'd actually use it?

AI has lowered the cost of testing ideas, so we should take advantage of that. Use prototypes to gather evidence instead of treating their existence as evidence.

3. Decide whether the capability is yours to own.

Some features belong at the heart of your product. They reflect your industry expertise, proprietary workflows or unique understanding of your customers and their data.

Others are capabilities customers expect but don't necessarily distinguish you from competitors. Now, those still need to exist, but the question is whether your engineers should build and maintain them, or whether a partner can provide them.

This is the ownership decision at the top of the Decision Stack we explored earlier in the series.

4. Account for the commitment, then prioritize.

Before comparing shortlisted ideas, estimate what each idea will demand after launch.

Who will maintain it? What will it cost to operate? What dependencies will it introduce? How much engineering attention will it need when something changes?

You won't have perfect answers, but even rough estimates can reveal when a cheap prototype is about to become an expensive responsibility. Once you've worked through those questions, RICE or your preferred prioritization framework can help decide what to tackle first.

The important thing? You're comparing opportunities your organization has consciously chosen to pursue.

What this means for AI analytics

If you lead a B2B SaaS product with monetizable data or insights, I'd bet analytics requests account for a meaningful share of your product backlog.

Can customers export this report? Build their own dashboard and drill in any direction? Ask questions about their data in natural language and ask for strategy plans?

Each request might sound manageable, and with AI coding tools, some might be surprisingly easy to prototype. But consider what happens when you keep accepting them individually. Eventually, you're responsible for a custom analytics capability, complete with semantic layers, tenant permissions, query performance, governance and ongoing improvements.

Your team may have made perfectly reasonable decisions about each feature. Yet, taken together, those decisions have committed you to owning something much larger.

That's where the Three-Layer Model for Intelligent Products becomes useful.

Layer 1 is your competitive advantage: the domain expertise and workflows that make your product worth choosing.

Layers 2 and 3 cover the intelligent analytics experience and the foundation supporting it.

With ThoughtSpot Embedded, your team can provide those analytics capabilities without having to develop and maintain the entire stack itself. You'll still decide how analytics fits your product, what customers need and where it creates value. But every new analytics request doesn't have to become another custom engineering project.

Ultimately, that leaves more room on your roadmap, and more engineering attention for the capabilities that differentiate your product.

The product backlog isn't the problem

I think the explosion of prototypes is a good thing. More people can test ideas, explore customer problems, and show what's possible, but we should use that freedom wisely.

We should also stop treating every working prototype as something that deserves a permanent place in the product. Otherwise, we'll end up with backlogs full of things we can build, without enough thought about which ones we should own.

The goal isn't to clear the backlog faster, but to make better decisions about what gets into it.

That means getting more comfortable with a skill that will matter much more: saying no. Build what differentiates you →


Next in the series: When building gets cheap, strategically saying “no” gets more valuable. Why product leaders need to become more selective about where their teams invest.