Initium: Simplifying Digital Life Management

🔹Situation:

HP set out to build Initium – a new security and “digital life” platform that unifies password management, subscription tracking, and notification controls into a centralized, privacy-first experience.

At the start, there was no UI, no user flow, no design system, and no interaction model – only a conceptual vision of a cross-platform assistant that could eventually support AI-powered security insights and recommendations across devices and services.

Research and internal feedback highlighted:

  • Fragmented control panels across apps and OS settings.
  • Buried subscription and billing controls, leading to wasted spend.
  • Confusing notification hierarchies and unclear risk levels.

Initium was conceived to close these gaps by delivering a modular, accessible, and trustworthy UX foundation at the OS level – and to be structurally ready for future AI-driven detection, coaching, and alerts.

🔹Task:
As the Senior Product Designer, I was responsible for:

  • Defining the UX foundation from the ground up.
  • Building a scalable atomic design system and tokenized component library.
  • Architecting cross-platform UI patterns (desktop + mobile).
  • Designing seamless flows for complex tasks around Passwords, Subscriptions, and Notifications.

Beyond just “making it usable”, the system had to:

  • Feel modern, secure, and empowered.
  • Support clear risk communication and user control.
  • Be structurally prepared for AI-powered scenarios such as suspicious login detection, password hygiene coaching, and subscription waste alerts.

🔹Action:

  • Translated the high-level “digital life assistant” vision into a concrete product structure, defining information architecture and interaction models from scratch.
  • Developed a tokenized component library using Atomic Design principles, with support for ADA compliance, dark/light themes, and HP brand alignment.
  • Designed core flows for Passwords, Subscriptions, and Notifications, with a focus on clarity, affordance, and progressive disclosure of security details.
  • Defined AI-powered security scenarios at the concept level (suspicious login assistant, password hygiene coach, subscription risk & waste alerts) and mapped them into concrete UX patterns.
  • Created a reusable pattern for AI-driven alerts:
    Signal → Reasoning → Confidence → Action set so that every future AI feature would be explainable and controllable rather than “magical”.
  • Embedded key trust principles into the UX: no silent irreversible actions, layered disclosure of details, clear severity levels, and consistent interaction patterns across features.
  • Partnered with product, engineering, and accessibility stakeholders to define MVP scope, success metrics, and a realistic evolution path from rule-based patterns to learning systems.
  • Reskinned the legacy EveryKey mobile app using Initium’s design system to establish visual consistency and hierarchy without backend changes quickly.
  • Led all system documentation, responsive layout guidelines, and multi-platform design decisions to support future AI integrations without redesigning the core UX.

🔹Result:

  • 🧱 Built a complete zero-to-one design system supporting multiple security-related product modules under a single UX language.
  • 📱 Designed and prototyped cross-platform UIs for desktop, iOS, and Android, ready for implementation.
  • ⚙️ Delivered a fully tokenized component library, engineered for accessibility today and AI-scale extension tomorrow.
  • 📈 Accelerated design velocity and dev collaboration through reusable patterns, clear documentation, and consistent interaction models.
  • 🔄 Modernized the EveryKey app using Initium’s UI logic, improving visual clarity, information hierarchy, and trust signals.
  • 🔐 Positioned Initium not just as a static control center, but as a modular, AI-ready, privacy-centric security platform that can evolve from deterministic rules to intelligent, learning systems over time.

🔷 1. Project Overview

Initium is HP’s new digital autonomy and security platform, designed to give users one trusted place to manage passwords, subscriptions, and system-level notifications across devices.
Instead of scattered settings and opaque control panels, Initium provides a unified, privacy-first experience where people can see what’s happening, what’s risky, and what they can do next.

As the Strategic Product Designer, I led the end-to-end UX architecture, co-created the atomic design system, and delivered responsive desktop and mobile flows for this zero-to-one product. There was no prior UI, component library, or interaction model — everything from information architecture to interaction patterns had to be defined from scratch.

My focus was to build a modular, ADA-compliant foundation that feels secure and empowering today, while being structurally ready for AI-powered detection, coaching, and recommendations in future releases.

🔷 2. How Initium works

At its core, Initium brings three critical problem areas into a single, consistent experience:

  • Passwords – managing credentials, reuse risks, and account security.
  • Subscriptions – tracking what you’re paying for, what’s overlapping, and what’s unused.
  • Notifications – controlling which apps and services can demand your attention, and how urgently.

Instead of treating these as separate tools, Initium acts as a central control center:

  1. It aggregates signals from accounts, devices, and services (such as logins, billing events, and alerts).
  2. It organizes them into clear, task-oriented modules (review passwords, clean up subscriptions, tune notifications).
  3. It applies a consistent interaction model for both current rules and future AI-driven insights.

For alerts and recommendations, we use a repeatable pattern:

  • Signal – what the system noticed (e.g., “New login from an unusual device.”).
  • Reasoning – why it matters (e.g., “You’ve never signed in from this location before.”).
  • Confidence – how specific the system is (e.g., “Likely safe”, “Needs your attention”).
  • Action set – a small set of clear options (e.g., “Trust this device”, “Review devices”, “Secure my account”).

This structure lets Initium start with deterministic rules and later evolve into learning systems and AI models, without changing users’ mental model. The experience stays explainable and controllable, even as the intelligence behind it becomes more sophisticated.

🔶 3. Problem Statement & Design Opportunity

Problem

Modern users are overwhelmed by disjointed control panels and inconsistent system behaviors across their digital life:

  • Password managers feel isolated from broader security workflows.
  • Subscription settings are buried across apps and platforms, leading to wasted spend and surprise renewals.
  • Notifications arrive without apparent urgency or hierarchy, creating fatigue, confusion, and missed critical signals.

On top of that, early explorations of Initium suffered from fragmented UX and legacy UI:

  • There was no cohesive design system, no modular logic, and no consistent interaction patterns across features.
  • Early screens reused outdated components from the EveryKey mobile app, causing clashes in visual style, missing affordances, and poor information hierarchy.
  • Critical signals — such as alert severity, toast confirmations, and interaction feedback — were either absent, inconsistent, or misleading.

Users didn’t just lack a single place to manage passwords, subscriptions, and notifications — they also lacked a trusted, explainable system that could help them understand what’s risky, what’s wasteful, and what to do next.

Design Opportunity

Initium was created to unify these fragmented experiences into a single, intuitive, and modular interface — a privacy-first control center where users can:

  • See all their credentials, subscriptions, and alerts in one place.
  • Understand which items are safe, which are risky, and which are simply wasting money or attention.
  • Take confident action through clear, predictable patterns instead of hunting through scattered settings.

When I joined as the first product designer on Initium, the opportunity was twofold:

  1. Fix the immediate UX and system gaps

  • Replace the ad-hoc, legacy UI with a custom atomic design system tailored to Initium’s needs.
  • Establish visual clarity across modules and consistent interaction patterns that build emotional trust.
  • Create a scalable, accessible architecture aligned with HP’s brand and platform constraints.

  1. Lay the foundation for an AI-powered future

  • Structure passwords, subscriptions, and notifications in a way that supports future AI-driven detection, coaching, and recommendations (for example, suspicious login assistant, password hygiene coach, subscription waste alerts).
  • Define UX patterns for signals, reasoning, confidence, and actions so that when AI is introduced, its behavior remains explainable and controllable — not magical or opaque.

🧠 4. Research & Key Insights

Primary Persona: Peter, A multitasking professional and parent who values clarity, speed, and low-friction tools that save time and money.

Insights Discovered:

  • Skepticism around auto-save and device pairing
  • Notification fatigue due to non-actionable alerts
  • Manual subscription tracking caused financial stress
  • Power users demanded vault-level control, while casual users preferred simplified visual cards

“I just want to stop wasting time resetting passwords or finding who pays for Hulu.”

📊 5. Competitive Benchmarking

We audited tools like 1Password, Dashlane, and Cleanfox, identifying critical gaps:

Gaps Identified:

  • No single tool unifies password + subscription, + alerts under one UI
  • Poor accessibility support (no token-based themes)
  • No cross-device personalization or family features

Design Inspiration

  • Spotify’s usage-based timelines for visualizing subscription frequency
  • Apple’s smooth modals and contextual transitions for task-based overlays

🛠️ 6. UX Strategy & Design Process

Approach:

I structured the work around the Double Diamond model — Discover → Define → Design → Deliver — while building a scalable design system using Atomic Design.

  • In Discover / Define, we focused on understanding how people currently manage passwords, subscriptions, and notifications across scattered tools, and where control, risk, and cognitive load break down.
  • In Design / Deliver, the goal was to create a unified, explainable experience that feels trustworthy today and can support AI-driven security insights in future releases.

The design system itself followed Atomic Design:
Tokens → Atoms → Molecules → Organisms → Templates → Pages, giving us a clear hierarchy for both current features and future modules.

I ran weekly design rituals with the Design Architect and PMs to align on interaction patterns, security UX guardrails, and how future AI scenarios would plug into the system without breaking the mental model.

Design Strategies:

To make Initium both scalable and AI-ready, I focused on a few key strategies:

  • Color-token-first theming
    Built a color-token system that supports dark/light themes, ADA contrast requirements, and clear risk states (informational, warning, critical) across all modules.
  • Modular wrappers for responsiveness
    Defined Small / Medium / Large layout wrappers so components could adapt cleanly across desktop and mobile without reinventing screens per device.
  • Component-to-screen logic tied to a consistent visual system
    Ensured every screen could be constructed from reusable organisms and templates, so new features (including future AI-driven surfaces) can be assembled quickly while maintaining consistency.
  • Early focus on interaction modules that signal trust
    Prioritized design and validation of Toasts, Info Bars, and alert banners as foundational “trust primitives” — clarifying what happened, why it matters, and what the user can do next.
  • Patterns for future AI recommendations
    For alerts and recommendations, establish a reusable pattern — Signal → Reasoning → Confidence → Action set — so that future AI features (suspicious login assistant, password hygiene coach, subscription waste alerts) can plug into a stable, explainable UX pattern instead of inventing a new interaction each time.

Trade-offs:

To ship a credible Phase 1, we made deliberate trade-offs:

  • Deferred rich AI onboarding flows and conversational assistants to later phases, so we could first ship rock-solid password, subscription, and notification flows with clear, deterministic behavior.
  • Designed the architecture, components, and alert patterns to be AI-ready, even if the underlying intelligence starts as rule-based. This allowed the team to add more advanced detection and coaching capabilities over time without reworking the core UX.

🔶  Design System

I helped lead the design system creation, including foundational tokens, ADA-compliant dark/light themes, and reusable components to ensure visual and behavioral consistency across the product.

The system was built using atomic principles, supporting future modules and minimizing engineering rework through scalable design patterns.

🔹 7. AI-Powered Security & Recommendations

Designing Initium for AI-powered security

While Initium started as a secure, unified place to manage logins, passwords, and subscriptions, we deliberately designed it to be ready for AI-driven security and recommendations.

Instead of treating every login or subscription as a static record, we framed Initium as a system that can:

  • Detect unusual behavior (locations, devices, time-of-day patterns).
  • Spot risky patterns in how people reuse passwords or ignore alerts.
  • Surface actionable suggestions instead of passive dashboards.

AI-powered security scenarios (concept level)

We mapped several high-impact scenarios where AI could add real value:

1. Suspicious login assistant

  • Detects unusual sign-ins (new device, new country, odd time) across different services.
  • Explains why the login looks suspicious and offers simple options such as:
    “Trust this device”, “Sign out everywhere”, or “Reset password”.

2. Password hygiene coach

  • Identifies reused or weak passwords across multiple accounts.
  • Prioritizes the riskiest accounts and guides users through a focused cleanup flow rather than overwhelming them with a long, static list.

3. Subscription risk & waste alerts

  • Flags overlapping or unused subscriptions (for example, multiple streaming services or forgotten trials).
  • Suggests concrete actions: cancel, downgrade, or consolidate – and shows the potential monthly savings.

For each scenario, we designed not just the UI, but the **conversation between the AI and the user**: what data is exposed, how confident the system appears, and how much control the user should have at each step.

From raw signals to explainable, controllable UX

In a security product, “AI detected something” is not enough. People need to understand:

  • What exactly was detected?  
  • How serious is it?  
  • What can they do about it?

We defined a repeatable pattern for AI-driven alerts in Initium:

  • Signal – what the system noticed (e.g., “New login from an unusual location.”).  
  • Reasoning – why it is considered risky (e.g., “You haven’t logged in from this country before.”).  
  • Confidence – an indication of how specific the system is (e.g., “Likely safe”, “Needs your attention”).  
  • Action set – two to three clear next steps with different levels of friction (e.g., “Ignore for now”, “Review devices”, “Secure my account”).

By structuring AI output this way, we keep security **explainable, not magical**, and maintain a balance between proactive help and user control.

Trust, explainability, and control in AI-assisted security

To make AI feel safe in a security context, we baked in several UX principles:

  • No silent, irreversible actions: AI can recommend, pre-select, or draft changes – but final confirmation stays with the user.
  • Layered disclosure: High-level alerts first (“Something looks unusual”), with an option to drill into details (“Show me the device, IP region, and history”).
  • Clear severity levels: Not every alert is a crisis. Visual hierarchy and language reflect whether an event is informational, a warning, or critical.
  • Consistent patterns across features: Whether it’s a login alert or a subscription recommendation, the structure is the same: what we saw → why it matters → what you can do.
  • Escape hatch by design: Users can always opt out of a recommendation, mark something as “safe”, or downgrade the sensitivity of alerts.

These patterns position Initium as a platform where **AI, security, and UX work together**: the system feels intelligent and proactive, without ever feeling out of control.

🧪 8. Usability Testing & Validation

Testing Methods:

  • Structured QA reviews with PMs and engineers
  • Figma prototype walk-throughs with real-time feedback overlays

Key Outcomes:

  • 22% increase in task success rate for password save/edit flows
  • 40% reduction in design-to-dev miscommunication via component standardization
  • Notification hierarchy testing confirmed the need for urgent vs. passive tiering

🎨 9. Final UI & Prototypes

Design Highlights:

  • Dark mode UI aligned to Initium’s ADA-compliant token set
  • Responsive components for cards, toasts, toggles, and modals
  • Notification tray with urgency-based sorting
  • Fully synced with the Katana Component Library

🌀 Design Evolution Example: Password Save Flow

We explored multiple variations for task clarity, visibility of saved states, and hover feedback. This final version strikes a balance between discoverability, error prevention, and accessibility.

“We conducted prototype reviews with four internal users. Feedback showed a preference for passive vs. interruptive notifications and strong clarity around new password save/edit UI.”

I collaborated cross-functionally with engineering and senior design leadership to ensure the system’s feasibility, accessibility compliance, and scalability. My focus was on strategic UX thinking, component clarity, and consistency across breakpoints.

📈 10. Anticipated Impact & Business Value

Because Initium is a recently launched product, usage data is still being collected. However, based on internal benchmarks and design strategy goals, the system is expected to drive meaningful outcomes across support, engagement, and product retention:

  • 🛡️ 20–30% reduction in support tickets related to password recovery and subscription confusion
  • 💬 Improved adoption of privacy tools and notification settings through intuitive IA and ADA-compliant flows
  • 🧠 Lower user fatigue via tiered alerts, visual hierarchy, and standardized interaction patterns
  • ⚙️ Faster development velocity through reusable atomic components and tokenized design logic

🔮 11. Future Roadmap & Next Steps

Not all of Initium’s intelligence needs to be “pure AI” from day one. We designed the product to evolve along a realistic path, starting from clear rules and moving toward learning systems.

1. Rule-based patterns

  • Start with deterministic rules (for example: new device + new country + short session length = flag as unusual).
  • Use these patterns to validate whether users find alerts helpful or noisy.
  • Keep the criteria transparent so security and compliance teams can review and adjust them.

2. Heuristics and feedback loops

  • Incorporate user feedback such as “This device is safe” or “This alert was not helpful” to refine thresholds and reduce false positives.
  • Track which alerts users act on and which ones they ignore to tune the system over time.

3. Learning systems

  • Gradually introduce ML-based models for anomaly detection and subscription insights, using the existing UX patterns for transparency and control.
  • Let the models optimize behind the scenes, while the UX stays consistent: clear signal, reasoning, confidence, and actions.

Designing Initium this way means we don’t have to “sell an AI story” that the product can’t support yet. Instead, the UX, information architecture, and design system are all **ready for an AI-powered future** – starting with rules, then heuristics, and eventually fully learning systems.

Planned enhancements (examples):

  • LLM-powered onboarding assistant that helps new users connect accounts and conversationally understand their security posture.
  • Contextual toast recommendations when the system detects wasteful or risky patterns, such as “You’re paying for multiple overlapping streaming services.”
  • Smarter notification controls that adapt frequency and sensitivity based on how each user responds to alerts over time.

✏️ 11. Key Learnings & What’s Next

  • Systems thinking upfront enables scalability across complex domains.
  • Cross-platform UI alignment is critical when designing for security-conscious users.
  • Next steps include refining notification tiers, adding biometric flows, and preparing Initium for future AI integrations.