Vital by ShareCapsule: Building a Local-First Daily Wellness System

Most wellness apps begin with a category: meditation, exercise, sleep, journaling, or habit tracking.

We started from a different question:

What are the small actions that help someone support their day as a whole?

That question gradually became Vital by ShareCapsule, a mobile-first, installable wellness PWA built around breathing, movement, learning, recovery, connection, and reflection.

The goal is not to build another app that asks people to achieve perfect scores or maintain endless streaks. The goal is much simpler:

Make small positive actions easy to start, repeat, and understand.

Vital is currently built as a local-first Progressive Web App. It does not require an account for the core experience, and the current product stores activity history, routines, settings, wellness check-ins, gratitude metadata, learning reflections, and sleep check-ins in the browser rather than sending them to a central cloud database.

Why we built it this way

Modern wellness products often become complicated very quickly.

A simple breathing timer turns into a subscription. A journal turns into a social network. A sleep feature becomes a scoring system. A basic health activity starts asking for an account, profile, notification permission, location, and multiple integrations before the user receives any value.

We wanted the opposite experience.

A user should be able to open Vital and immediately do something useful.

No signup.

No onboarding wall.

No mandatory cloud account.

No requirement to hand over personal wellness data just to use a breathing timer or complete a reading session.

This led to three product principles:

Value first. Privacy by default. Complexity only when it creates real value.

Six daily foundations

Vital now organizes the experience around six simple foundations:

• Breathe — guided breathing practices such as Thirumoolar Pranayama.

• Move — stretching, mindful walking, and movement breaks.

• Learn — intentional reading and Active Recall.

• Restore — sleep reflection and evening wind-down.

• Connect — gratitude and the “Thank Someone” practice.

• Reflect — voice wellness check-ins and meditation.

These are not meant to become six compulsory tasks.

The interface deliberately says:

Aim for balance, not perfection.

The system looks at what the user has done locally during the day and marks which foundations have been supported. Reading or Active Recall can support Learn. A sleep check-in or wind-down activity can support Restore. A gratitude moment supports Connect. A confirmed self-check-in or meditation can support Reflect.

That creates a broader picture of the day without turning well-being into a competition.

Reading and Active Recall

One of the more interesting additions is the connection between reading and memory.

Most apps would implement reading as another timer.

Vital instead encourages a simple learning loop:

Read → close the source → recall from memory → review what was missed → keep one key idea.

The user can complete an intentional reading session and move directly into Active Recall.

This makes learning part of well-being rather than treating it as a completely separate productivity category.

The detailed recall itself does not need to become another cloud data stream. Vital can keep lightweight learning reflections locally and use them to help the user understand their own practice.

Gratitude as connection, not gamification

The “Thank Someone” feature came from another simple idea.

Most of us have people who influenced our life but whom we do not see every day.

Vital invites the user to think of one such person, record a short voice message, listen to it, and share it if they want.

The recording uses browser microphone capabilities such as getUserMedia and MediaRecorder.

Importantly, Vital does not create a gratitude leaderboard or pressure users to maintain a gratitude streak.

The app stores lightweight metadata about the gratitude moment, while the raw recording is not persisted into history.

That distinction matters.

The product should encourage connection without turning appreciation into another metric to optimize.

Voice check-ins without pretending to read emotions

Voice Check-in is another area where we intentionally avoided an easy but questionable product shortcut.

Vital does not attempt to determine a person's emotional state from vocal tone, pitch, prosody, or other biometric characteristics.

Instead, the user answers a simple question:

How are you feeling right now?

Where browser support exists, Vital can use Speech Recognition to transcribe what the person says. The user then confirms or corrects the mood label before it is stored.

This keeps the meaning with the user.

The system records a self-reported wellness label—not an AI diagnosis.

The current technical architecture

The present application is intentionally lightweight.

At the client layer, Vital is a React + TypeScript application built with Vite. The current dependency set is small and does not include a backend framework, vector database, RAG system, or embedded LLM SDK.

The application uses hash-based navigation for Today, Routines, Progress, Settings, Voice Check-in, AI sharing, and activity-specific pages such as Reading, Active Recall, Restore, Thank Someone, and Thirumoolar Breath.

The basic architecture is:

User
  ↓
Browser / Installed PWA
  ↓
React + TypeScript + Vite
  ↓
Daily Foundations / Activities / Routines
  ↓
Browser APIs
  ↓
Local browser storage
  ↓
Progress / Goals / Weekly balance
  ↓
Optional user-controlled sharing

The current local storage layer contains things such as activity completions, goals, routines, schedules, settings, confirmed wellness check-ins, gratitude metadata, learning reflections, and sleep check-ins.

There is no mandatory application backend for the core wellness experience.

Why a PWA?

A Progressive Web App gives us an interesting middle ground.

Vital can behave like a website when someone discovers it through a link, but users can also add it to their Home Screen and use it more like an application.

That matters for onboarding.

The first interaction can simply be:

Open → use an activity → receive value.

Only later does the user need to decide whether they want to install it, enable reminders, or use external integrations.

The production deployment is currently straightforward:

GitHub repository
      ↓
GitHub Actions
      ↓
TypeScript validation
      ↓
Vite production build
      ↓
GitHub Pages
      ↓
health.sharecapsule.org

The deployment workflow builds the dist artifact and publishes it through GitHub Pages.

The current production branch also uses a service worker to support application caching, controlled updates, and notification routing.

AI is optional, not the center of the architecture

AI is intentionally not placed in the middle of every Vital interaction.

Vital currently has no RAG pipeline, vector database, retrieval service, or embedded AI agent.

Instead, AI sharing works from the outside.

If the user chooses to share progress, Vital builds a privacy-filtered progress object using the versioned schema:

sharecapsule.health.progress.v1

The user can decide whether goals, streaks, recent activity names, confirmed check-ins, or gratitude counts should be included. The resulting summary can then be copied, downloaded, or sent through the device share sheet to a preferred assistant or app.

The sharing screen uses browser capabilities such as navigator.share and the clipboard rather than automatically calling an AI service.

That creates an important boundary:

Vital manages the wellness experience. The user decides when an external AI should become involved.

This also means Vital does not need to store ChatGPT, Gemini, Claude, or other API keys in the browser.

What the architecture deliberately does not contain

The current system does not have:

Cloud-based personal wellness profiles.

A centralized user database.

RAG or vector search.

Automatic AI interpretation of every activity.

HealthKit or Health Connect ingestion.

Verified step competitions.

Automatic emotion recognition from voice.

These may not all remain absent forever, but any future addition should solve a real user problem rather than exist simply because the technology is available.

That principle becomes increasingly important as AI makes features easier to build.

The question is no longer:

Can we add this feature?

The better question is:

Should this feature exist, and does it improve the user's life without unnecessarily increasing complexity or data exposure?

Where Vital can go next

The architecture gives us room to grow.

Native HealthKit and Health Connect integrations can eventually support reliable step tracking.

Groups can allow families, communities, schools, and organizations to run wellness programs.

Verified activity can support fair challenges and awards.

Cloud accounts can be introduced as an optional capability for users who want cross-device synchronization.

AI can eventually help summarize patterns or suggest routines—but only with explicit user authorization.

And the six Daily Foundations can continue expanding while keeping the core interaction simple.

The larger idea

Vital is ultimately an experiment in a different kind of health and wellness software.

Instead of maximizing screen time, it should help someone do something useful and return to their life.

Instead of collecting every available data point, it should collect only what is necessary.

Instead of demanding an account before delivering value, it should earn the user's trust first.

Instead of using AI simply because it is fashionable, it should introduce intelligence only where it genuinely improves the experience.

The product philosophy can be summarized in one sentence:

Small habits. Better well-being.

Vital by ShareCapsule is still evolving, and that makes this the best time for feedback.

Try it at:

health.sharecapsule.org