For years, I’ve worked on backup, sync, and data continuity systems — the plumbing that quietly keeps a user’s digital world intact. And like many PMs who own long-running platform features, I’ve spent a lot of time asking the same question: What does “good” actually look like here? Backup succeeds. Sync succeeds. The device restores. The checkboxes are green.
So… is that the end of the story?
The more time I spent owning this area, the more I realized something subtle but important: our industry has focused on functional restoration, not human restoration. We restore the device, but we don’t restore the person using it. That’s not because anyone overlooked something — it’s because our current systems were never designed to understand the broader context of a user’s digital life. The OS brings back preferences, files, and settings, but the deeper layers that shape how people work still fall through the cracks.
And as we think about the future of operating systems — especially in a decade where intelligence, automation, and personalization are becoming foundational — those cracks matter.
This realization led me to a bigger question: What if continuity wasn’t just a feature, but an operating principle? What if an OS evolved from managing apps and devices to understanding the user behind them?
Where continuity breaks today
Modern operating systems do a solid job restoring the visible parts of a user’s setup — wallpaper, themes, language preferences, and certain system settings. Cloud backup brings files back. Apps re-download. On paper and theory, everything looks “restored,” and most dashboards/reports would call that a win.
But when you look at how people actually use their devices, it becomes obvious that this only scratches the surface of what makes an environment feel like their environment.
What’s missing is the deeper state behind the experience — the app configurations, notification preferences, privacy decisions, window layouts, workflows, multi-desktop setups, and the small habits that shape a user’s day. These rarely come back cleanly. Some aren’t restored at all. Some are stored by apps inconsistently. Others require users to rebuild things manually. The result: the device looks familiar, but it doesn’t feel familiar.
Figure 1: Apps may restore after device recovery, but the workflow often does not — creating a real continuity gap for users.
A simple example of this shows up in something as common as a multi-window workspace. Many people rely on a predictable setup — email on one side, a browser in the center, a notes app tucked on the right. After a device restore, all three apps reinstall successfully, yet none of them return to the layout the user is accustomed to. Technically, everything is “there.” Experientially, everything is missing. The user spends the next several minutes resizing, rearranging, and reconstructing a workflow that previously felt automatic. This gap — between restoring apps and restoring the way someone works — is exactly where continuity breaks down.
A simple way to understand the gap is through the distinction between preferences and state. Preferences are the cosmetic or one-time choices — wallpaper, colors, languages, default apps. State is everything that reflects how the user operates: which notifications they care about, which apps interact, which permissions they’ve granted, how windows are arranged, what tasks were in progress, and how work flows across devices. Today’s systems mostly restore preferences. They rarely restore state.
A snapshot of the difference:
Figure 2: Preferences are what the OS restores today; state is what makes a device feel personal.
Restored today: wallpaper, themes, lock screen, language settings, files via cloud, some system toggles, and an app reinstall list.
Still missing: app-level configurations, extensions, login state, detailed permissions, notification behavior, workspace layouts, browser/tasks context, and cross-device patterns that reflect real workflows.
This isn’t a product or engineering failure — it’s simply the limit of the current OS model. But from a product perspective, it creates a meaningful gap: we restore the device, not the person using it. As computing becomes more connected, more distributed, and more intelligence-driven, that gap becomes much harder to ignore.
Why this matters now
This matters now because the way people use technology has changed. Most of us move between multiple devices throughout the day, and we expect our experience to follow us — not just our files or wallpaper. At the same time, more features across the OS and apps are starting to rely on user context to work well, whether that’s recommendations, automation, or light-touch AI assistance. But today, that context is scattered and often has to be relearned from scratch each time a user switches devices. Add to that a growing set of privacy requirements around how data is accessed and shared, and it becomes clear that the system — not individual apps — needs to take more responsibility. These shifts are exposing the limits of the current OS model and making it obvious that we need a more data-aware and privacy-aware foundation before AI truly becomes a natural part of everyday computing.
What needs to change
I don’t believe we need a brand-new operating system tomorrow or a complete architectural rewrite. What we need is a shift in how we think about continuity and user experience at a foundational level. Instead of focusing only on restoring devices, we need to design systems that remember how people work — their flows, their preferences, their boundaries, and the context they build over time. This doesn’t require a single “big bang” solution. It requires treating user data as a meaningful product surface instead of something scattered across apps and services.
Whether platforms adopt deeper system APIs, better privacy scaffolding, or more resilient sync models, the direction is clear: continuity needs to move closer to the person, not just the machine. Users shouldn’t have to piece their workflow back together or renegotiate basic behaviors every time something changes. The system should meet them where they are, carry forward what matters, and preserve the context that shapes their work.
The opportunity for PMs
For product managers, continuity often shows up as a maintenance area — stable, low-risk, and largely solved. But when you look at how people actually use their devices, it becomes clear that continuity is quickly becoming one of the most strategic layers of the modern computing experience.
It affects trust, personalization, and productivity. It is increasingly shaped by privacy expectations and regulatory requirements. And when things break, users rarely blame the individual app or subsystem; they blame the platform. When things go well, the impact is quiet but meaningful — onboarding feels natural, cross-device usage becomes seamless, and intelligent features have the context they need to feel genuinely helpful.
The shift ahead for PMs is moving from asking “Did the device restore?” to asking “Did the experience resume?” That mindset changes how we design platform capabilities, how we measure success, and how we think about data flows.
One practical way for PMs to think about this is to map their product’s “experience resume.” List the core workflows your users rely on, note what needs to be remembered for those workflows to resume naturally, and mark what currently persists versus what silently resets. Even lightweight insights — like which view a user prefers, where they left off in a reading task, or how they arrange panels — can dramatically improve continuity when preserved across sessions or devices.
The OS shouldn’t just restore settings — It should restore the User
After owning this space for years, one lesson has become hard to ignore: we’ve built operating systems around apps and devices, but the next decade will be about building them around people. The building blocks are already in place — strong sync infrastructure, modern privacy frameworks, and emerging intelligence capabilities — but what’s missing is a shift in how we treat user data. Instead of viewing it as a scattered byproduct of apps and services, it needs to become a first-class part of the product experience.
The OS of the future won’t just power computation; it will protect identity, understand context, preserve continuity, and bridge intelligent features with user control in a way that feels safe and predictable. In simple terms, it will help restore the human behind the screen, not just the settings around them. If continuity in the last decade was about saving files and syncing preferences, continuity in the next decade will be about preserving the person — their habits, their workflows, and the context that makes technology feel effortless.
