From Bundling To Bonding: The Unbundling–rebundling Cycle Now Happens Inside A Single Sku.
A decade ago, “bundling vs. unbundling” was primarily a market-structure story. New entrants unbundled suites into more sharply focused point solutions. Incumbents rebundled by acquiring those point solutions, stitching them into platforms, and selling the bundle again. The pattern was visible at the company level: the CRM suite, the marketing cloud, the ITSM platform, and the productivity suite.
That cycle still exists—but something more consequential has happened inside the product itself.
Today, the unbundling–rebundling cycle often plays out within a single SKU, on a single contract, behind a single login. Leaders want products that feel tailored to each team, each role, each workflow, even each moment. But they also want the economics and governance of utilities: standardized procurement, consistent controls, predictable reliability, and scalable operations. The product has to behave like a concierge without being staffed like one.
This is the new mandate: architect “bonding,” not just bundling.
Bundling is about packaging value. Bonding is about making the product feel like it understands the customer—without collapsing into bespoke implementations that cannot scale. Bonding is the craft of personalization with utility economics.
This essay lays out what has changed, why enterprise leaders should care, and how product builders can design offerings that deliver intimate experiences at an industrial scale.
Why The Cycle Moved Inside The Sku
Three forces pushed the bundle–unbundle game from the market to the interface.
First: the suite has become the default procurement posture.
Enterprise buyers have spent the last decade living with SaaS sprawl. Most leaders now recognize that sprawl is not just cost; it is integration debt, identity chaos, fragmented analytics, and governance fatigue. Many organizations still tolerate sprawl, but the center of gravity has shifted: standardize where you can, specialize where you must.
The average enterprise still runs an extraordinary number of apps—often north of 100—creating fertile ground for suite vendors to sell consolidation narratives and for platform teams to push standardization.
Second: software distribution has been absorbed by ecosystems.
In many categories, it is harder than ever for a new point solution to win distribution without riding an incumbent’s marketplace, directory, or installed base. Aggregators and platforms reduce customer switching appetite and increase the value of “already deployed.” This dynamic is visible across consumer and enterprise markets, and it underpins modern rebundling strategies.
Third: feature modularity is now technically trivial and commercially powerful.
Feature flags, entitlements, and configuration services enable product teams to ship a single codebase while exposing radically different experiences to different segments. That means unbundling can happen at the “capability” level: one user sees a lightweight workflow; another sees an advanced automation studio; a third sees an AI copilot; all inside the same SKU.
In practice, this means a product can sell (and deliver) a bundle while revealing it as an unbundled set of experiences. The bundle becomes hidden infrastructure; the user experience becomes individualized.
The New Product Paradox: Personalization Without Bespoke
Enterprise leaders increasingly demand personalization—but not the old kind.
Old personalization was professional services: custom fields, custom dashboards, custom workflows, and custom integrations. It delivered specificity, but it also created brittle snowflakes that were expensive to maintain and nearly impossible to upgrade.
New personalization is behavioral: the product adapts without becoming unique. It feels personal because it is context-aware, not because it is custom-built.
This shift matters because personalization is no longer a “nice to have”; it is an economic lever. Research frequently cited by McKinsey reports that personalization often drives a 10–15% revenue lift (with a range of 5–25% depending on sector and execution). McKinsey also notes that personalization can materially reduce acquisition costs and improve marketing ROI, pointing to a broader pattern: when personalization becomes operational (not just marketing), it compounds.
But enterprise-grade personalization runs into a hard constraint: governance. The more a product adapts, the greater its risk of becoming unpredictable. Leaders do not just want “smart”; they want accountable, auditable, secure.
So the objective is not personalization at any cost. The objective is personalization that remains legible to IT, controllable by administrators, and consistent under scale.
Bundling Vs. Bonding: The Distinction That Matters Now
Bundling optimizes for the buying moment.
It simplifies pricing, reduces procurement friction, and increases perceived value. The product’s internal complexity is hidden behind a single number and a clear plan tier.
Bonding optimizes for the lived experience over time.
It reduces cognitive load, anticipates needs, and makes adoption feel natural. Bonding is not “more features.” It is the right surface area for the right user at the right time, with the right guidance and the right defaults.
Bundling says, “Here is everything you might need.”
Bonding says, “Here is what you need now—and the rest is there when you are ready.”
This distinction is the reason the unbundling–rebundling cycle moved inside the SKU. The bundle is still how you monetize and govern, but bonding is how you drive usage, retention, expansion, and long-term differentiation.
The Architecture Of Bonding: Six Layers That Make Personalization Scale
To make bonding real, product leaders need to stop treating personalization as a UI trick. Bonding is a system. The most effective products build it through six layers.
Layer 1: A stable, utility-grade core
A product cannot personalize sustainably if its core is fragile. The “utility” standard means:
• Reliability and performance that do not degrade with complexity.
• Consistent identity and access controls.
• Backward-compatible APIs and stable data models.
• Predictable change management.
Without a core designed for repeatability, every personalization becomes an edge-case tax.
Layer 2: An entitlement and packaging layer
This is where “unbundling inside the SKU” becomes manageable. Entitlements determine which capabilities exist for which customer, which team, and which user.
Crucially, entitlements should not just mirror pricing tiers; they should support:
• Role-based capability sets (admin vs. operator vs. analyst).
• Departmental profiles (sales vs. IT vs. finance).
• Maturity stages (basic workflows vs. advanced automation).
• Compliance needs (regulated controls vs. lightweight defaults).
When entitlements are cleanly separated from code, product teams can reshape bundles without rewriting the product.
Layer 3: A context layer (who, what, where, why)
Bonding requires context. That includes:
• User identity and role.
• Team membership and permissions.
• Workflow state (what is happening now).
• Historical behavior (what they have done before).
• Organizational constraints (policies, data residency, audit requirements).
This is where many products fail: they “personalize” based on shallow segmentation (industry, company size) rather than operational context. Bonding requires a living model of the customer’s work.
Layer 4: A decision layer (rules + learning, governed)
This layer decides what to show, recommend, automate, or suppress.
In mature bonding systems, this is a hybrid:
• Deterministic rules for safety and compliance.
• Learned models for prioritization, ranking, and recommendation.
• Guardrails and auditability so decisions are explainable and testable.
Feature flagging and targeting platforms are practical expressions of this layer: they enable shipping a single product and selectively activating behaviors based on context.
Layer 5: An experience layer (progressive disclosure and “just-in-time” surfaces)
Bonding is not just what the product can do; it is what it chooses not to show.
Progressive disclosure is the most underappreciated “rebundling” technique: keep the SKU broad, keep the initial experience narrow. Reveal capabilities through:
• Triggers (user reaches a threshold).
• Journeys (onboarding paths by role).
• Situational UI (surfaces that appear only when relevant).
• Embedded assistance (AI or guided workflows that reduce training burden).
Layer 6: An economics layer (pricing that matches value without exploding complexity)
Bonding collapses if pricing fights it. If a user experiences the product as personalized, but procurement experiences it as opaque or unpredictable, trust erodes.
This is why “utility economics” matters. Many SaaS businesses are moving toward hybrid models that blend seats, usage, and outcomes. Industry reporting suggests consumption-based approaches are increasingly common, with multiple surveys showing meaningful adoption and acceleration.
The key is not to chase novelty. The key is to match price to the “unit of value” that bonding unlocks—while remaining forecastable enough for enterprises to commit.
The Enterprise Buyer Who Hates “choice,” But Demands Control
Consider a familiar scene: a Fortune 500 CIO joins a quarterly business review with a major SaaS vendor. The vendor arrives with a roadmap of dozens of new features, several AI capabilities, and new add-ons. The CIO’s first reaction is not excitement; it is suspicion.
The enterprise does not want more options. It wants fewer surprises.
But in the same meeting, the head of Sales Ops complains that reps are wasting time on low-value tasks, the CISO demands tighter controls, and the CFO wants usage tied to outcomes. Different leaders want different “products,” but no one wants to buy five separate tools.
This is bonding’s job: reconcile personalized demands into a single governable platform. The buyer wants a bundle on paper and a bespoke experience in practice—without bespoke risk.
If the vendor cannot deliver that, the enterprise does what it always does: it reintroduces point solutions at the edges, and sprawl creeps back in.
How The Best Products Rebundle Inside The Sku
Several patterns have emerged in modern software that effectively deliver “unbundled experiences within bundled economics.”
Pattern A: Collections and role-based suites
Some vendors increasingly group products into collections that map to job-to-be-done clusters while keeping them within a single contractual universe. Atlassian’s packaging and collection language is illustrative: customers can price and buy “collections” and then operate across multiple tools with shared identity and governance.
This is rebundling optimized for the org chart: teams feel like they have “their product,” procurement feels like it has “one vendor.”
Pattern B: Embedded marketplaces as controlled unbundling
Marketplaces allow controlled extension without surrendering governance. The platform rebundles third-party innovation under its administrative umbrella.
Pattern C: AI as a rebundling layer
AI copilots increasingly act as a “unified interface” across a bundle: users request outcomes, and the system orchestrates the underlying tools.
This is not just convenience; it is a strategic response to suite complexity. If the bundle is broad, AI helps narrow it.
Pattern D: Progressive capability unlocks
Advanced products deliberately delay complexity. They guide users into mastery stages rather than presenting the entire platform upfront.
This is how a single SKU can serve both a novice team and a power user organization without fragmenting the product line.
Why Adobe’s Subscription Era Illustrates The Dynamics (And The Risk)
Adobe’s shift to Creative Cloud is often framed as a pricing transformation: perpetual licenses to subscription bundling. But it also demonstrates the rebundling inside the SKU pattern.
Creative Cloud bundled a broad set of tools into a subscription, then let users experience it as a personalized “workspace” tailored to their craft: photography, video, design, or enterprise collaboration. Over time, Adobe embedded AI capabilities (Firefly and related tools) to make the suite feel more assistive and workflow-aware.
Public reporting and financial disclosures indicate meaningful growth in Adobe’s subscription-driven business across years, and more recent reporting highlights AI-driven engagement metrics (including very large monthly active user counts for freemium products) and revenue growth expectations.
The lesson is not “copy Adobe.” The lesson is that rebundling can succeed when the product simultaneously:
• Makes the bundle feel like an ecosystem of tailored workflows.
• Uses embedded intelligence to reduce complexity.
• Maintains a single economic and governance frame for enterprise buyers.
The risk is also clear: when a bundle becomes too heavy, customers interpret it as forced consumption. That is why bonding matters: it prevents the bundle from feeling like bloat.
Pricing For Bonding: How To Monetize What Feels “custom” Without Custom Prices
Pricing is where many bonding strategies fail. The product feels personal, but the commercial model is either too simple (leaving money on the table) or too complex (creating friction and distrust).
A practical pricing playbook for bonding typically includes four mechanisms:
Mechanism 1: Anchor tiers, then personalize within them
Enterprises still prefer tiers. Keep tiers stable and legible. Personalize experiences through entitlements and UI targeting rather than endlessly proliferating SKUs.
Mechanism 2: Add usage meters only where the unit of value is obvious
If you meter something customers cannot intuit, they will experience billing as punishment. Use metering where value scales with consumption in a way customers accept (transactions, compute, automations, messages).
Mechanism 3: Treat AI like a capacity layer, not a “mystery tax.”
AI features are increasingly bundled, but many vendors add ambiguous AI surcharges. Bonding-friendly pricing frames AI as:
• A capacity pool (credits or usage caps).
• A tier differentiator (higher plans get more).
• A clearly metered value unit.
Mechanism 4: Align expansion with organizational adoption, not feature accumulation
Bonding should increase stickiness and expansion by spreading through roles and teams. Pricing should reward that spread (enterprise agreements, platform commitments) rather than forcing buyers into constant add-on negotiations.
Design Principles For Product Leaders: Five Non-negotiables
For founders, product executives, and enterprise platform leaders, bonding becomes manageable when translated into principles.
Principle 1: Separate “capabilities” from “experiences.”
Build a capability graph. Then create multiple experiences that reveal different slices of that graph by role and context.
Principle 2: Make personalization auditable
If the system adapts, administrators must be able to answer: “Why did this user see that?” Without auditability, personalization will be disabled.
Principle 3: Default to progressive disclosure
Do not ship complexity as a first impression. Bonding requires restraint.
Principle 4: Treat governance as part of the experience
Bonding is not just for end users. IT and security leaders are users too. Admin UX is not secondary; it is a trust infrastructure.
Principle 5: Keep the economic model aligned with the customer’s mental model
If customers cannot explain their bill, bonding turns into resentment.
What Enterprise Leaders Should Do Next: A Boardroom-level Checklist
Bonding is not just a product strategy; it is a vendor strategy and an operating model question. Leaders can act in three immediate ways.
Action 1: Evaluate products on “adaptability under governance.”
When reviewing vendors, ask:
• Can we tailor experiences by role without custom development?
• Can we centrally control and audit that tailoring?
• Does the vendor have mature entitlements and admin tooling?
Action 2: Demand measurable reductions in operational friction
Bonding should reduce training time, support tickets, and “work about work.” Ask vendors for evidence: onboarding completion rates, time-to-first-value, and adoption metrics segmented by role.
Action 3: Align procurement with utility economics
If leaders want platforms that behave like utilities, they should structure contracts like utilities: predictable base commitments plus transparent variable components tied to value.
The Future Belongs To Products That Feel Intimate And Run Industrial
The unbundling–rebundling cycle has not ended; it has compressed. It now happens continuously within the product through entitlements, targeting, and context-aware experiences. The winners will be the teams that treat this not as packaging, but as architecture.
Bundling will remain the commercial wrapper. But bonding will decide whether the wrapper becomes sticky value or resented bloat.
For product builders, bonding is the discipline of building a utility-grade core with an adaptive, contextual edge. For enterprise leaders, bonding is the filter for choosing platforms that can scale across the organization without turning into sprawling, fragile messes.
The next generation of category leaders will not win by shipping more features. They will win by making a single SKU feel like it was built for each customer—while operating like a public utility behind the scenes.
