0. Introduction & Product Overview

WhatHappened is a memory operating system for individuals and families.

At its core, it solves three problems:

We remember more than we can organize.
People have tens of thousands of recallable memories, but they are scattered, fragile, and hard to find when they’re needed.
Our memories are deeply social and contextual.
The stories that define us are wrapped up in other people, places, eras, songs, and world events. No existing tool treats that full context as a first-class citizen.
Most memory tools are either static (journals, scrapbooks) or overwhelming (genealogy, archival systems).
People need something that feels playful and approachable, but powerful enough to grow into a family and legacy platform.

WhatHappened combines three layers into one product:

A public, RAG-powered cultural timeline (“What was happening in the world?”)
A personal and family memory vault (“What was happening in your life?”)
A set of AI-guided experiences (prompts, interviews, games, and visualizations) that make capturing and revisiting memories enjoyable.

Over time, WhatHappened becomes:

an externalized long-term memory,
a family storytelling hub,
and a contextual history engine that can answer questions like:

“What was going on in the world when my grandfather was 20?”
“What was my mom doing when I was in middle school?”
“What were my own big life events around the time of 9/11 / COVID / the Challenger explosion?”

The system is designed to start small—one person capturing a few stories—and then expand naturally into:

couples using it on date nights,
families using it in “Memory Night” sessions,
and future generations using it as a living archive of voices, stories, recipes, photos, and timelines.

This master plan describes the conceptual architecture of WhatHappened: how memories are modeled, captured, organized, connected, and experienced. It also marks several TBD technical areas (infrastructure, security, identity, data schema, and detailed UI) that will be specified in later phases.

1. Core Philosophy & Memory Model

1.1. Philosophy: “What Happened” vs. “The Story We Tell”

The product name points to a key distinction:

There is what happened (the event itself).
There is how we remember it.
There is the story we tell ourselves about what it meant.
And sometimes there is the fuller truth we learn later.

WhatHappened is designed to hold all of these layers, not just a cleaned-up final version.

For example:

Event: “Dad left when I was four.”
Interpretation at the time: “I wasn’t lovable enough to stay for.”
Later understanding: “He was battling addiction and mental health issues.”
Current meaning: “This shaped my empathy and how I show up for others.”

The platform must be able to store:

the raw event,
the early interpretation,
the revised interpretation,
and the current meaning—

without overwriting earlier layers. This makes the vault not just a list of stories, but a record of how a person’s understanding of their life has evolved.

1.2. Time Is Multi-Layered: Event Time, Telling Time, Discovery Time

Every memory can be anchored to multiple points in time:

Event Time: When the thing actually happened.
- “The car accident in 1992.”
- “Grandpa’s war experience in the 1940s.”
Telling Time: When the story was told or recorded.
- “Grandpa telling the story at Thanksgiving in 1987.”
- “Mom telling you her childhood story over the phone in 2025.”
Discovery Time: When you learned something new that changed your understanding.
- “In 2020 I learned the real reason we moved.”
- “In 2030 I read the letter that clarified what really happened.”

WhatHappened treats all three as important.
A single “memory object” can therefore have:

one or more event dates (if the story spans a period),
one or more telling dates (stories that get told many times),
and one or more discovery dates (when new context arrived).

This allows the system to answer complex questions like:

“Show me stories that were told to me in childhood about much earlier events.”
“Show me things I misunderstood for years and only got clarity on later.”
“Show me memories that have changed meaning over time.”

1.3. Multi-Perspective Memories

Different people often live through the same event but remember it very differently.
WhatHappened treats this as a feature, not a bug.

A single “event” (e.g., “The Thanksgiving incident in 1994”) may have:

Eric’s version of the story,
Vikki’s version,
Mom’s version, and
maybe even Grandpa’s version told years earlier.

The system must:

link these tellings as perspectives on the same underlying event,
preserve each version in its original voice,
and optionally generate a combined narrative that highlights:
- where they agree,
- where they differ,
- and what unique details each person remembers.

From a data perspective, that means:

a Shared Event object,
with multiple Story Versions attached,
each owned by a different user or recorded for a different person.

From a user’s perspective, this feels like:

“Hear it as Eric remembers it.”
“Hear it as Vikki remembers it.”
“Hear the full composite story, stitched together.”

This is core to the product’s emotional power.

1.4. Stories, Chunks, and Micro-Memories

To balance narrative richness with retrieval accuracy, the system uses a three-layer memory structure:

Stories – longer, narrative forms:
- A complete telling of an event or theme.
- Often spoken aloud and transcribed.
- May include multiple scenes and side stories.
Chunks – atomic, retrievable units of knowledge:
- 1–3 sentences each.
- Each chunk carries a single idea, event, or fact.
- Used for search, RAG responses, and precise recall.
Micro-Memories – very small fragments or details:
- A smell, a sound, a single image.
- Examples: “The smell of Grandma’s kitchen,” “The sound of gravel under the bike tires.”
- Often stored as attributes attached to chunks or stories, but visible to the user as “sensory details.”

In practice:

The user tells or uploads a Story.
The system breaks it into Chunks and identifies micro-memories.
The user can browse and search at any level:
- “Show the whole story,”
- “Show just the key moments,”
- or “Show all the tiny details I’ve ever recorded about Grandma’s house.”

This structure is also what lets the system be both:

a beautiful narrative vault (for humans), and
a precise knowledge base (for AI retrieval).

1.5. Anchors: People, Places, Objects, Themes

Human memory is not stored as a neat list of events—it clusters around anchors:

people (Mom, Grandpa, RJ),
places (the Lexington house, the Arlington apartment),
objects (Grandpa’s hammer, the blue Schwinn bike),
themes (school, church, vacations, pets),
and sensory anchors (smells, songs, foods).

WhatHappened models these anchors explicitly. Every memory can be linked to:

one or more people,
one or more places,
one or more time periods,
one or more themes (e.g., “holidays,” “work,” “health”),
and optionally one or more objects.

Anchors act as:

organization structures (“Show me all stories involving Grandma.”),
prompt drivers (“Tell a memory about this house.”),
and visual hooks in the UI (people graphs, place maps, category boards).

You’ve already identified several especially powerful anchors that must be first-class:

People: Mom, Dad, siblings, grandparents, children, close friends.
Places: each home, school, workplace, town, and special locations (e.g., “the lake house,” “the Lexington land”).
Pets: pets often hold as much emotional weight as people.
Food & Recipes: favorite foods, restaurant memories, and family recipes, together with the stories behind them.
Life domains: school, church, sports, hobbies, jobs, health events, vacations.

Anchors are how the system makes memory capture approachable (“Start by telling me about your pets”) rather than overwhelming.

1.6. Placeholders: “Story Seeds” for Later

Memory doesn’t always arrive in complete form. Often, you briefly remember something but don’t have time or emotional bandwidth to tell the whole story.

WhatHappened therefore supports placeholders:

fast, low-friction “story seeds”
a few words or a short phrase
logged as “Needs Expansion”

Examples:

“The red boots in kindergarten”
“The Lexington ice storm”
“Grandpa’s hammer prank”
“The time the dog ruined Thanksgiving”

Placeholders are critical because they:

allow high-volume brainstorming sessions,
prevent memories from slipping away,
and create a backlog of prompts the system can circle back to later.

The AI can periodically surface these placeholders:

“You saved this memory seed: ‘The red boots in kindergarten.’
Want to tell that story now?”

This mechanism is central to large-scale memory capture.

1.7. Emotion, Meaning, and Impact

Not all memories are equal. Some are trivial; others are identity-shaping.

The system should allow (and sometimes gently prompt) users to add:

emotional tags (joy, fear, embarrassment, pride, grief),
impact tags (life-changing, pivotal, minor, funny),
and meaning notes (“This is why this memory sticks with me,” “This moment changed how I see myself,” etc.).

This enables:

queries like “Show me the 10 memories that most shaped who I am,”
personalized story generation (chapters by emotional theme),
and deeper self-understanding over time.

1.8. Public vs. Private Layers

Even though WhatHappened will support shared family vaults and collective storytelling, the core memory model is privacy-first:

Every memory has an owner.
Visibility can be:
- Only me (Inner Vault),
- My family vault,
- Specific people,
- Public (for selected things, if the user wants),
- Or time-delayed (e.g., “Only after I die”).

The memory model therefore always includes:

ownership,
visibility level,
and sharing rules,

even when stories are about other people.

Technical details (encryption, access control) will be specified in later sections, but the philosophical baseline is:

The user controls who sees which parts of their life story, and when.

2. User Types & Primary Use Cases

WhatHappened is designed to grow with the user over time and to support multiple kinds of storytellers, archivists, and family members. Although a single individual may play several roles, the product must recognize and support distinct user types, each with different needs, motivations, and behaviors. These user types also naturally correspond to different subscription tiers and product features.

Below is a detailed breakdown of the primary user categories and the use cases most important to each.

2.1. The Individual Storykeeper (The Core User)

This is the foundational user type. An Individual Storykeeper is someone who wants:

a place to remember more of their life,
a system to organize personal history,
or a legacy archive for their family.

Their dominant needs:

Capture memories quickly (before they fade)
Find memories easily (searchable life archive)
Explore their past and see it organized visually
Tell stories in their own voice
Understand how life events connect
Record memories that others can access someday (optionally)

Their high-frequency behaviors:

Speaking into the system using voice capture
Uploading photos and adding descriptions
Browsing memories through timelines and categories
Responding to prompts like “Tell me about your first car”
Creating placeholders for later
Editing and refining stories over time

This user is the heart of the product. All other user types build on top of this base experience.

2.2. The Family Historian / Memory Architect

This user is deeply motivated by preservation, especially across generations. They often:

handle genealogical work,
organize old family photos,
care for aging parents or grandparents,
or simply want to honor the stories of people who may not be here forever.

Their dominant needs:

Capture stories from older relatives
Record family lore before it’s lost
Build life timelines for other people (Mom, Dad, grandparents)
Organize memorabilia (letters, journals, recipes, heirloom explanations)
Reconstruct events from multiple perspectives
Understand family dynamics across generations

Their behaviors:

Sitting with an older relative and recording stories
Uploading old documents
Categorizing and tagging family photos
Scanning old recipe cards, handwriting samples, scrapbooks
Rebuilding timelines for relatives who never used digital tools
Connecting family members’ stories to each other (“Link this story to Grandma’s timeline”)

This user is especially important because they often become evangelists inside a family. Their passion for preservation drives family-wide adoption.

2.3. The Family Network (Couples, Siblings, Parents, Kids)

This category includes:

couples using WhatHappened to understand each other
siblings sharing childhood stories
parents preserving memories for adult children or vice versa
whole families using the Family Vault to add multiple versions of the same event

Their dominant needs:

Shared storytelling
Capturing different perspectives
Seeing overlapping life timelines
Resolving or enjoying differences in recollection
Building a shared narrative of the family’s history

Their behaviors:

Participation in “Memory Night” sessions
Tagging each other in memories
Responding to prompts like “Your sister added a memory you were part of. What do you remember?”
Collaborating on family timelines (holidays, trips, traditions)
Uploading group photos and identifying everyone in them

This user type reinforces the social and emotional fabric of the product.

2.4. The Legacy Builder (Future-Facing User)

This user is motivated by:

mortality,
legacy,
meaning,
and wanting to be remembered accurately.

They may be in midlife or older, and they want to leave behind:

their stories,
their values,
and the lessons learned throughout life.

Their dominant needs:

Record stories in their authentic voice (audio + transcription)
Explain the meaning behind events
Organize memories into narratives (e.g., “My life story”)
Control who gets access and when
Support “after-death release” or time-delayed access

Their behaviors:

Recording long-form stories
Tagging stories with moral lessons or reflections
Preparing timelines and memory maps
Marking memories as “for my children only” or “for after I’m gone”

This is an especially sticky user segment — they value the product deeply and stay engaged.

2.5. The Elder Loved One (Someone Whose Stories Are Being Captured)

This user may not operate the system directly. Instead:

a child, grandchild, or friend
records stories on their behalf.

Their dominant needs:

Be heard and remembered
Have their stories preserved accurately
Have someone help them tell stories they may not fully recall at once

The system must support:

multiple versions of a story told by them at different ages
capturing their voice (audio is priceless)
making it easy for others to build their timeline
letting them contribute casually (“I remember…”) without formal input screens

This category is the emotional core of the product — capturing stories before they are lost is an urgent use case.

2.6. The Curious Explorer

Some users aren’t initially motivated by storytelling. They’re motivated by:

nostalgia,
curiosity,
trivia,
learning history in a fun way.

These users often come in through the public timeline, not the personal vault.

They may spend hours:

scrolling year-by-year,
playing timeline games,
seeing what music, movies, and news shaped certain eras.

Their dominant needs:

Engaging content
Trivia-style experiences
Gamified prompts
Connecting world history to their own memories

This user type is essential for Top-of-Funnel growth — they become paid users once they want to add their own timeline.

2.7. The Couple or Close Friend Pair Using Memory Nights

This is a unique social use case.

Couples (or sometimes friends) use WhatHappened to:

get closer,
share stories they’ve never told each other,
talk through pivotal life moments,
or walk through old photos and tell stories while the system captures everything.

Their needs:

Prompt-driven conversations
A fun, “date night” experience
Shared vault space
Audio capture for two-person dialogues
Story stitching (“generate the combined memory”)

WhatHappened must feel intimate and emotionally enriching for them.

2.8. The “Future Child” Use Case (Parents Capturing for Unborn or Young Children)

This is a powerful long-term segment:

Parents often want to capture:

stories from the time before a child was born,
milestones during early childhood,
stories about grandparents the child may not remember,
and emotional messages for future years.

Needs:

Capture memories “for” someone else in advance
Store milestone events
Save audio messages addressed to the child
Generate a curated “life book” later

This use case grows naturally into family vault adoption.

2.9. Summary: Why Multiple User Types Matter

WhatHappened is not a single-purpose product like a journal, digital scrapbook, or genealogy tool. It spans all three categories. Supporting multiple user types ensures:

wide adoption,
long engagement,
deep emotional investment,
and network effects within families.

Each user type also validates a core feature group:

Storykeeper → memory capture & organization
Family Historian → adding other people’s timelines
Family Network → multi-perspective memories
Legacy Builder → meaning, voice preservation, privacy
Elder → audio capture, assisted storytelling
Curious Explorer → public timelines & gamification
Couples/Friends → conversational capture
Future Child use case → time-delayed legacy

Together, they form the backbone of the product’s long-term viability.

3. Knowledge Architecture: Public Timeline, Cultural RAG & Private Vaults

The power of WhatHappened comes from the way it blends personal memory with world context. Most memory tools historically focus on only one of these dimensions:

Journals → purely personal
Timelines & encyclopedias → purely historical
Genealogy → family-structured, but not story-rich
Photo albums → image-driven, but under-contextualized

WhatHappened unifies all three.

This section describes how the system’s knowledge layers work together:

The Public Timeline (a cultural chronology of events, prices, inventions, songs, movies, etc.)
The Cultural RAG Engine (a retrieval model built on the public timeline data)
The Personal & Family Vaults (private memories, timelines, media, and meaningful life events)
The Overlay Mechanism (how the system maps world events onto a user’s life and vice versa)

Together, these layers form a contextual memory environment that provides meaning, triggers recall, and supports storytelling at a level no isolated memory app can achieve.

3.1. The Public Timeline (Free & Always Accessible)

The Public Timeline is the top-of-funnel feature that anyone can view, even without an account. It is essentially a living encyclopedia of:

major world events (politics, economics, wars, disasters)
cultural moments (fashion trends, slang, subcultures)
entertainment history (movies, TV, books, games)
music charts (top songs per year or per week)
technology milestones
economic markers (average home prices, gas prices, wages)
scientific discoveries
sports highlights
pop icons, brands, and nostalgic touchpoints

This timeline is not meant to be exhaustive or academic — it is optimized for memory triggers.
The guiding question is always:

“Would this spark a memory for someone who lived through that year?”

Thus, the timeline emphasizes:

sensory experiences
cultural moods
iconic products
common daily life experiences

Example timeline items for 1991:

Music: Nirvana’s Nevermind hits #1
Movies: Terminator 2 releases
Tech: First real webcam goes online
Politics: Soviet Union dissolves
Daily Life: Super Nintendo becomes wildly popular
Economy: Avg. U.S. rent ~$500/month
Nostalgia: Lisa Frank school folders everywhere

Every item is short, scannable, and designed to evoke a reaction:
“Oh wow, I remember that!”

This makes the Public Timeline both a fun browsing experience and a powerful recall engine.

3.2. The Cultural RAG Engine (Free Tier Upsell Driver)

The Public Timeline becomes dramatically more powerful when paired with a Cultural RAG (Retrieval-Augmented Generation) engine.

This RAG is trained on:

all Public Timeline entries
curated cultural datasets (music charts, film releases, major events)
structured metadata (year, category, region)
optional Wikipedia-sized cultural context (lightly indexed for relevance)

The goal is not encyclopedic accuracy — that role belongs to standard search engines.
The goal is:

Generate cultural context around a memory, a time period, or a question in a way that sparks personal recall.

Examples of interactions with the free Cultural RAG:

“What happened in 1987?”
“What were popular toys in the mid-90s?”
“What major events happened when I was in high school?”
“What movies came out the year my parents got married?”
“What was the world like when I was born?”

The Cultural RAG can also respond in different modes:

📌 Nostalgia Mode (Statler Brothers “Do You Remember These?” style)

List sensory and cultural items designed to evoke childhood memories.

📌 Event Mode (Billy Joel “We Didn’t Start the Fire” style)

Chop through major global events in rapid-fire format.

📌 Pop Culture Mode

Top songs, movies, foods, fashions, slogans, iconic products.

📌 Daily Life Mode

School life, shopping habits, toys, commercials, routines of the era.

This engine dramatically increases the emotional stickiness of the platform.
It also serves as the conversion lever:

Free users begin exploring history →
The system asks,

“Want to see what you were doing this year?”
→ Upgrade to create a personal vault.

3.3. Personal Vaults (Private, Structured Memories)

The Personal Vault is where the user’s memories live.
Its structure is rooted in the memory model described in Section 1:

Stories
Chunks
Micro-memories
Anchors (people, places, objects, themes)
Media (photos, audio, video, documents)
Dates (event, telling, discovery)
Emotion & meaning tags
Privacy settings
Placeholder memories
Categories & boards

Each Vault grows organically over time.
Some users will add:

one story a month;
others will add
fifty stories in a weekend;
others will use
Family Memory Nights to rapidly fill it;
and still others will
bulk upload old photos and prompt the system to extract memories.

Everything is searchable, retrievable, and woven into timelines and relationships.

The Vault is the “private half” of the WhatHappened ecosystem — deeply personal, protected, emotional, and infinitely expandable.

3.4. Family Vaults (Collaborative & Multi-Perspective Storytelling)

The Family Vault is an extension of the Personal Vault.

In a Family Vault:

multiple users have accounts
each person has their own private vault and shared access to a family space
stories can be linked
memories can have multiple versions
users can tag relatives who were present
the system can invite them to contribute their version (“Do you remember this the same way?”)

Family Vaults support:

multi-perspective storytelling
collaborative timeline building
richer context for old photos
better accuracy for reconstructing family history
cross-generational use

A Family Vault becomes, over time:

“Our family book, but alive and always growing.”

3.5. The Overlay System: Mapping Life Stories Against World History

One of the most magical features of WhatHappened is the overlay engine.
It connects:

a user’s personal timeline
to
the Public Timeline and cultural context.

The system can generate:

A. “What the world was like when you were [age X].”

Brings up:

music
movies
prices
fashion
technology
major events

and invites the user to add memories from that period.

B. “What your parents were doing when you were born.”

This requires the People Graph (Section 8) but is transformative.

C. “What was happening globally during your major life events.”

Examples:

“This is what the world looked like when you got married.”
“This is what was happening the year you moved to Lexington.”
“These songs were on the radio when you graduated college.”

D. “Which world events you actually remember.”

The system can ask:

“Do you remember the Challenger explosion?”
“Where were you when you heard Elvis died?”
“Do you remember what you were doing on 9/11?”

This creates potent memory anchors.

E. Personalized nostalgia feeds

Like Spotify Wrapped, but for memories:

“Your most active memory decade was the 1990s.”
“Here are the top songs associated with your stories.”
“Here are the people who appear most frequently in your memories.”
“Here are places that were central to your childhood.”

The Overlay System is where the private database and public database merge to create a fully contextual life map.

3.6. Emotional & Identity Context Layer

Memory is not just facts and dates — it is meaning.
WhatHappened uses the Public Timeline and the Cultural RAG to help users articulate:

how the world shaped them,
which eras influenced their identity,
what social environment they grew up in,
which cultural moments defined their adolescence,
which sentiments (hope, fear, change, rebellion, excitement) were present during key phases of their lives.

This layer is subtle, but profound.

3.7. Why This Knowledge Architecture Is Unique

Most “memory apps” only store content.
Most “history apps” only present facts.
Most “genealogy apps” only build relationships.

WhatHappened does something none of them do:

It contextualizes your life inside the world you lived in.

It turns the story of your life into the story of your era.

Your life is not isolated — it happened in a cultural moment.
This architecture reflects that truth.

4. Memory Anchors, Categories, Placeholders & Triggers

How the System Helps Users Remember Far More Than They Realize They Know

Most people dramatically underestimate the number of memories they still carry—often 50,000 to 100,000 retrievable memories if prompted effectively. The challenge is not that the memories are gone; it’s that the pathways to access them are rarely activated.

Section 4 explains how WhatHappened uses anchors, categories, placeholders, and dynamic triggers to draw out the deepest layers of a person’s remembered life—without overwhelming them, and without requiring them to sit for hours writing essays.

This system is one of the core innovations that separates WhatHappened from every other journaling, genealogy, or scrapbook tool ever created.

4.1. Memory Anchors: The Core Building Blocks of Recall

A Memory Anchor is any element that can pull a forgotten memory back into consciousness.
Most memories are not stored as full stories—they are stored as fragments connected to anchors such as:

People (Mom, Dad, Aunt Elsie, Coach Hernandez)
Places (the house in Lexington, Grandma’s kitchen, the creek behind the school)
Objects (the red Schwinn bike, a 1979 Oldsmobile, a favorite teddy bear)
Events (moving to Arlington, a school play, a wedding)
Themes (pets, food, vacations, holidays, jobs)
Media (songs, movies, commercials, toys)
Daily Life Routines (chores, family dinners, bedtime rituals)
Life Phases (childhood homes, high school years, early career)
Emotional States (fear, pride, embarrassment, joy)

Anchors are the “handles” on the drawers of memory.

When the system knows a user’s anchors, it can begin unlocking dozens—sometimes hundreds—of memories tied to each one.

Why anchors matter

A story rarely exists in isolation. It is tied to:

the house where it happened,
the people present,
the song on the radio,
the object in the scene,
the season of life.

Anchors allow a fragmented memory to be expanded into a fuller narrative.

4.2. Categories: The User’s Personal Memory Framework

While anchors tend to be small and specific, categories are broader organizing structures.
They act like buckets into which memories naturally fall.

The system includes default categories such as:

Homes & moves
School years
Pets
Vacations
Cars
Jobs
Foods & restaurants
Recipes & cooking
Holidays & traditions
Friendships
Sports & extracurricular activities
Health & challenges
Love & relationships
Milestones (weddings, graduations, births)

But one of the most powerful features is the ability for users to create custom categories, such as:

“Church youth group”
“Grandma’s house in Lexington”
“Working at the mall”
“College dorm life”
“Rodeo days”
“RPG nights with my friends”
“Our first apartment together”
“Dad’s workshop”

Categories give users a personalized index of their life.

They also serve as giant prompts, because seeing a category often returns dozens of memories instantly.

4.3. Placeholders: Fast, Frictionless “Memory Seeds”

Most memory-capture systems fail because they demand too much work from the user upfront.

Writing a full story takes time and emotional energy.
But remembering a story is fast and spontaneous.

That’s why WhatHappened introduces Placeholders—short, incomplete memory seeds that can be expanded later.

A placeholder might be:

“The time we almost missed the cruise ship.”
“Dad’s 1971 Ford truck and the broken door.”
“The Thanksgiving my aunt set the rolls on fire.”
“My first dog — the one that ran away twice.”
“The Lexington tornado — ask Mom for details.”

A placeholder can be:

a title
a sentence
a keyword
a voice note
a fragment
a reminder to talk to someone else
an incomplete thought

The key is speed.
The moment a memory flashes into your mind—even if you can’t tell the story right now—you capture the clue.

The placeholder becomes a “memory to be filled in later.”

This mirrors your workflow when you used WordPress drafts to store hundreds of childhood memory triggers.

Why placeholders matter

People will:

remember 200 memories in a single sitting
but only have time to write down 10
unless you give them a frictionless way to store fragments

Placeholders dramatically expand the initial content of a vault.

4.4. Dynamic Triggers: Smart Prompts That Pull Out Hidden Memories

The system doesn’t wait for the user to remember everything.
It actively interviews them.

Dynamic triggers fall into several categories:

A. Identity Triggers

“Where did you live at age 10?”
“Do you remember your first pet?”
“Who taught you to drive?”
“What cartoons did you watch growing up?”

B. Contrast Triggers

If a user answers No, the system asks:

“Why not?”

Examples:

“Did you play any school sports?” → No → “What made you decide not to?”
“Did you learn a musical instrument?” → No → “Was there a reason you weren’t interested?”

Absence creates meaning. The “why not?” often produces richer stories than the “yes.”

C. Event Triggers

“Do you remember where you were when the Challenger exploded?”
“Do you remember hearing about Princess Diana’s accident?”
“Do you remember how you felt during the COVID lockdown?”

These create potent memory anchors.

D. Sensory Triggers

“What foods remind you of your grandparents?”
“What smells bring you back to childhood?”
“What songs take you to a specific moment?”

E. Timeline Triggers

Using the world timeline (Section 3):

“These songs were popular when you were 14. Do any of them spark a memory?”
“This movie came out your senior year of high school—did you see it?”

F. Cluster Triggers

Once one memory is captured, the system asks:

“Is this memory connected to any of these people, places, or events?”

This encourages chain recollection.

G. Story-Expansion Triggers

For any placeholder or story, prompts like:

“Who else was there?”
“What happened right before this?”
“What happened right after?”
“How did this make you feel at the time?”
“Do you remember the weather, the season, the room?”
“Were you proud, scared, embarrassed, excited?”

These expand a small fragment into a full narrative.

4.5. The “Memory Growth Loop” (How One Memory Becomes Many)

Memory recall naturally cascades.
WhatHappened builds a system around this psychology.

Memory Growth Loop:

User captures a memory or placeholder.
System extracts anchors (people, places, themes).
System prompts:
- related memories
- similar events
- additional details
- timeline context
User adds micro-memories or placeholders.
Loop repeats.

This loop is how a user can go from:

20 memories → 200 memories in a weekend
200 memories → 2,000 memories over the first year
2,000 memories → their entire life reconstructable

This is the “brain dump” effect you described—
getting stories out of your head creates psychological space for more to surface.

4.6. The Visible Memory Map (A Critical UX Feature)

Users must be able to see their memories to spark more.

This includes:

timelines
category boards
anchor maps
clusters
relationship diagrams
life phases
searchable lists
“density maps” showing which years are rich or sparse
“prompt me about this time period” buttons

Seeing memories visually gives users an immediate understanding of:

what they’ve captured
what’s missing
what they want to explore next

This visual representation is also motivating.
When users see progress, they add more.

4.7. Multi-Version & Multi-Perspective Memories

You introduced an important idea:

Sometimes people remember the same event differently.

The system fully embraces this.

When a user tags someone else in a memory:

that person can confirm it as-is
or say “My memory is a little different”
and record their own version

Both versions are preserved and linked.

This is a powerful family-history tool because:

contradictions are part of real stories
different perspectives create depth
families enjoy comparing versions
reconciling memories is itself meaningful

This becomes a collaborative act of oral history preservation.

4.8. Why These Components Matter Together

Without anchors, categories, placeholders, and triggers, users would only capture:

the most obvious 2% of their memories
a handful of major life events
scattered stories written only when they feel inspired

With this system, users capture:

thousands of memories
dozens of perspectives
forgotten events
sensory experiences
emotional turning points
context they never realized mattered

And most important:

They capture the truth of their life, not just the tidy “retellable” stories.

5. Multi-Person Timelines, Life Graphs & the People Map

Reconstructing Lives, Relationships, and Overlapping Histories Through Time

One of the most powerful innovations of WhatHappened is its ability to map not just one person’s life, but the intersecting timelines of many people—family members, friends, mentors, partners, ancestors, and anyone else who played a role in the user’s story.

Unlike genealogy tools, which show bare facts (birth dates, marriages, deaths), WhatHappened creates a living, emotional, relational map of human lives. It shows who mattered, when, and why—based on the stories people tell.

This section explains the architecture that supports multi-person timelines, overlapping histories, perspective-based memories, and the visual “People Map” that brings it all together.

5.1. Why Multi-Person Timelines Matter

Human memories are rarely isolated.
Every story is tied to people:

family members
classmates
neighbors
coworkers
romantic partners
friends from specific life phases
mentors
enemies
passing acquaintances whose presence mattered

And in many cases:

users want to reconstruct the lives of people who may never log into the system themselves.

For example:

A user wants to reconstruct their mother’s childhood.
A grandchild wants to piece together Grandpa’s WWII experiences.
Siblings want to compare their versions of shared events.
A user wants to build a memorial timeline for someone who has passed away.

To support this, WhatHappened needs:

independent life timelines for any person the user includes
the ability to link memories across those timelines
the ability to visualize how lives overlapped
a way to tag people within stories
a flexible system that allows non-user individuals to exist as full-fledged memory entities

This makes WhatHappened not only a memory vault but a relationship history engine.

5.2. Creating People Profiles (User and Non-User Individuals)

Each person—whether they have an account or not—can have a People Profile.

A People Profile includes:

Name
Relationship to the user
Dates of birth & death (if known)
Places they lived
Key life phases
Default categories (e.g., “Mom’s cooking,” “Dad’s workshop,” “Grandpa’s stories,” “College roommate years”)
Photos, videos, audio
Stories told by others
Stories they told (if captured during interviews)
A visible timeline of their life events
A map of when their life overlapped with the user’s

This is essential because memory is relational.
Your mother’s childhood, even if she never records a story herself, is still part of your story.

The system also allows:

multiple users in the same family account to contribute memories about the same person
versioning and perspective for stories involving multiple people
shared access permissions (e.g., the family vault model)

People Profiles become anchors for thousands of memories.

5.3. Overlapping Timelines: The Heart of Multi-Perspective Memory

Once People Profiles exist, the system can generate Overlapping Timelines.

These show:

where your timeline intersects with your mother’s
how old you were when she was 30
what she was doing when you were in high school
what major events were happening in the world at each intersection
what family members were alive, where they lived, and what was happening in their lives
who was present at certain milestones

This creates a context-aware memory graph.

For example:

You add a memory from 1991, when you were 12.
The system sees your mother was 33, your father 36, your sister 9.
It shows what city each person lived in, who else was in the household, and what world events occurred that year.

This context triggers more memories and helps users fill in missing details.

It also helps families reconstruct shared experiences from multiple angles.

5.4. Life Graphs: The Big Picture of a Person’s Story

A Life Graph is a visual representation of a person’s:

homes
jobs
relationships
major events
health events
milestone experiences
hobbies & passions
life transitions
tragedies and triumphs

A Life Graph helps users understand:

the arc of someone’s life
how stable or turbulent certain phases were
how memories cluster around specific periods
how different roles emerged (“student,” “parent,” “caregiver,” “veteran,” etc.)

Each Life Graph can include:

stacked timelines for events
visual density maps of memory clusters
emotional heatmaps
ages shown along the graph
connections to other people
external world events overlayed for context

Life Graphs become a powerful foundation for AI-assisted storytelling, such as:

“Summarize my father’s 20s.”
“Show me your grandmother’s hardest years.”
“Tell me how your life changed after 2005.”
“What were the happiest periods of your childhood?”

Because memories are chunked and tagged, the system can reconstruct believable, narrative-based insights.

5.5. The People Map: A Relationship-Centered Lens on Memory

The People Map is a central feature of WhatHappened.
It allows users to visualize:

who has been part of their life
how relationships changed over time
which people were present during specific memories
how many stories include each person
clusters of people who appear together frequently
relationship arcs (“closer in this period,” “drifted apart,” “reconnected later”)

The People Map operates like an interactive constellation:

Each person is a node.
Strength of connection determines how close the nodes appear.
Lines indicate shared memories.
Clusters emerge naturally.
Clicking a person brings up that person’s timeline, life graph, and all connected memories.

This is a relationship intelligence engine, unique in the memory-preservation world.

5.6. Multi-Perspective Memories (Revisited & Expanded)

When multiple people are tagged in a memory, the system:

identifies the memory as multi-perspective eligible
prompts each tagged person to contribute
stores each version separately
displays them side-by-side or in a layered view
highlights differences and agreements
time-stamps each version, capturing evolution of storytelling

Users love this feature because:

it reveals emotional truth
shows how memory is shaped by roles and age
becomes an instant conversation starter
creates the most human historical record possible

Perspective comparison becomes one of the signature features of the whole platform.

5.7. Building Timelines for People Who Are NOT Members (A Key Feature)

This is critical.

Many users will want to build:

their mother’s timeline
their grandmother’s timeline
their father’s military record
their uncle’s stories
their great-grandparents’ migration journey

These individuals may:

never log in
not be alive
not be available
not want to participate

But their lives still matter deeply to the user.

So WhatHappened supports:

creating any number of non-user People Profiles
recording interviews with them (if alive)
importing letters, diaries, photos
capturing stories about them from multiple family members
building a timeline from research (e.g., census, social media, obituaries, military records)

This allows families to create:

digital biographies
memory-based family trees
reconstructed narratives
cross-generational archives
shared heirlooms of information

This feature alone could become a cornerstone of family legacy preservation.

5.8. Three Tiers of Multi-Person Functionality (Feature Packaging)

As you suggested, these features lend themselves to tiered subscription levels.

Tier 1: Individual Account (Base Plan)

User stores their own memories
Public timeline access
Single-person life graph
Can tag others but can’t create full timelines for them

Tier 2: “Build Their Story” Add-On

Create unlimited People Profiles for others
Build timelines for parents, grandparents, children, friends
Upload stories, audio, photos about them
Generate life summaries and life graphs for non-users
Compare multi-perspective stories (when other family participates informally)

Tier 3: Family Vault (Premium Plan)

Everyone gets their own login
Shared timelines and stories
Multi-perspective recording
Group memory nights, games, prompts
Cross-linked People Maps
Shared access to ancestral timelines
Multi-user collaboration

This structure aligns value with price and clearly segments the product.

5.9. Why This Matters for Storytelling, Legacy & Identity

These tools turn scattered memories into a coherent narrative of human lives.

They allow people to:

understand where they came from
see how family stories shaped them
reclaim memories they hadn’t thought about in decades
understand their parents’ and grandparents’ lives in richer detail
gain empathy
mend relationships
preserve heritage
create a permanent archive for future generations

WhatHappened becomes:

a biography generator
a relationship explorer
a historical contextualizer
a family-history reconstruction tool
a personal meaning-making engine

And it does so through AI that is respectful, contextual, and grounded in the user’s own storytelling.

6. Memory Accuracy, Story Evolution & Truth vs. Interpretation

Designing a System That Preserves Both Facts and the Human Experience of Remembering

Memory is not a perfect recording device.
It is a living, evolving process that blends:

what happened,
what we believed happened,
what we later learned,
and what we now understand about it.

For WhatHappened to become the world’s most accurate, emotionally intelligent memory vault, it must embrace the full spectrum of human remembering, not just the factual layer. This means the system must allow:

partial memories
contradictory versions
evolving interpretations
corrections and updates
emotional overlays
meaning assigned later in life
“I only learned the full story years afterward” scenarios

This section outlines how the platform stores, compares, contextualizes, and presents memories across time.

6.1. “What Happened” vs. “The Story I Told Myself”

Borrowing from transformational learning principles (including the Landmark distinction you mentioned), every memory exists in two layers:

Layer 1: The Event (“What Actually Happened”)

These are the observable facts — or at least the user’s best recollection of them.

Examples:

“My dad left when I was four.”
“I struck out in the championship game.”
“We moved to Dallas when I was twelve.”
“I got into a minor car accident in college.”

Layer 2: The Meaning (“The Story I Told Myself About What Happened”)

This is the emotional interpretation, which is often far more influential than the event itself.

Examples:

“My dad left because I wasn’t lovable.”
“I embarrassed my team; I’m not good under pressure.”
“Moving to Dallas was the best thing that ever happened.”
“I became afraid of driving for years.”

The system should allow users to explicitly store these two layers as distinct but linked components.

Why this matters:

It reveals how beliefs shaped a person’s identity.
It helps future generations understand family emotional history.
It enables therapeutic insight without being a therapy tool.
It’s essential for accurate life narratives (and for AI-generated life stories).

The platform becomes not just an archive of events — but an archive of personal meaning.

6.2. Memory Evolution: How Stories Change Over Time

People retell stories dozens of times over their lives, often with:

added detail,
forgotten detail,
emotional shifts,
new information that reframes the event,
embellishment,
or contextual updates.

The system should support story evolution, including:

a. Version History

Each time a user modifies a memory, the system should:

store the new version,
preserve the older version,
timestamp both, and
optionally show a “story evolution timeline.”

This allows future readers to see:

how Grandpa told the story at age 40,
how he told it again at age 70,
and how details or emotions shifted.

b. Alternate Tellings (Multiple Versions Recorded at Different Times)

Sometimes an event is told with entirely different flavor or focus depending on:

audience
mood
age
stage of life

All versions should coexist, each tagged as a distinct telling.

c. Cross-Perspective Evolution

When multiple people contribute their versions of the same story, the system should highlight:

which details are consistent,
which differ,
where perspectives diverge,
and what each narrator emphasized.

This becomes fascinating for families — and profoundly human.

6.3. Partial Memories: Capturing Fragments Without Forcing Completeness

Many memories are incomplete:

“I vaguely remember a blue car…”
“I think it was fourth grade but I’m not sure.”
“I can remember the smell but not the place.”
“Someone told me this story; I don’t actually remember it firsthand.”

The system must embrace partiality as legitimate data.

Features needed:

Ability to mark a memory as uncertain or fragmentary
A field for “Missing Details I Wish I Could Remember”
Fields for “People who might know more”
AI suggestions for details based on context (without fabricating facts)
A way to revisit and update the memory later (“Return to this memory to fill gaps”)

Partial memories are often the seeds that lead to more complete reconstructions later.

6.4. The “I Thought X, But Later Learned Y” Structure

A memory often has a revelation layer, where the user learns:

they misunderstood something,
they only had half the story,
or they gained clarity years later.

Examples:

“I thought Mom canceled my birthday party because she was mad. I later learned she was in the hospital that day.”
“I believed Grandpa fought in WWII. Turns out he was stateside the whole time.”
“I thought my friend was ignoring me. I later learned her family was going through a crisis.”

The system should explicitly support this structure:

What I believed at the time
What I learned later
How that changed the meaning for me

This dramatically enriches the historical record and deepens emotional insight.

6.5. Truth, Perspective & Contradiction: The Family Memory Triangle

Families routinely have:

disagreements about what happened,
different emotional interpretations,
contradictory timelines,
conflicting recollections.

WhatHappened must not force reconciliation.

Instead, it must honor all perspectives with equal dignity.

This means:

preserving contradictory memories side-by-side
letting each version stand on its own
supporting a “Compare Perspectives” mode
allowing a combined AI-generated summary that includes disclaimers (“Eric remembers it this way; Vikki remembers it differently”)

This is one of the most compelling and differentiating features of the platform.

6.6. Accuracy Controls: Preventing AI Invention While Still Offering Insight

The platform must guard against hallucination when helping users reconstruct stories.

To do this, the system should:

a. Use retrieval-based generation only

AI can only use the user’s stored memories + verified public timeline facts.

It cannot invent missing details, such as:

names
dates
outcomes

Unless the user provided them.

b. Use uncertainty-friendly phrasing

For example:

“Based on your memory of being around 8 years old and living in Arlington, this event most likely occurred between 1987 and 1989.”

This is inference, not invention.

c. Allow user correction instantly

So the system learns their preferences and avoids unwarranted confidence.

d. Highlight inferred vs. factual details

A subtle visual indicator (e.g., dotted underline) shows which details are:

user-stated
user-confirmed
system-inferred
world-contextual

This creates a trustworthy, transparent memory reconstruction engine.

6.7. Emotional Encoding: Capturing How Events Felt, Not Just What Happened

Two people can share the same event but have completely different emotional experiences.

Therefore, each memory should optionally include:

emotion tags (“joyful,” “scary,” “funny,” “embarrassing,” “bittersweet”)
an emotional timeline (e.g., how feelings changed over the years)
reflection prompts (“How do you feel about this memory now?”)
sentiment shifts over time (“At the time, I was devastated. Now I laugh about it.”)

This turns the vault into a dynamic archive of emotional growth.

6.8. Memories as Threads: Connecting Events Across Time

A single memory may connect to:

people
places
objects
smells
foods
songs
holidays
pets
family traditions

The system should support threading, so memories can be linked together across:

themes
life chapters
emotional arcs
recurring events
repeated patterns
evolving relationships

This allows users to answer questions like:

“Show me all memories connected to Grandpa’s farm.”
“Show me every story that involves Christmas.”
“Show me the ways my relationship with my dad changed over time.”

Threading turns WhatHappened into a meaning-making engine, not just an archive.

6.9. The Memory Confidence Spectrum (A Required Metadata Layer)

Each memory can include a Confidence Rating:

High: “I am certain this happened this way.”
Medium: “This is generally correct, but some details may be off.”
Low: “This is vague or fuzzy.”
Reported: “Someone else told me this; I was not present.”

This helps:

family members interpret the story
the AI determine how to phrase summaries
users reflect on the reliability of their recollections
future generations understand the data

Over time, confidence ratings may increase as more perspectives are added.

6.10. Why This Section Matters

Most memory tools focus on:

dates
events
photos
factual accuracy

But human memory is:

interpretive
emotional
subjective
incomplete
evolving
relational

WhatHappened’s power lies in honoring all of these layers.

By designing explicitly for:

multiple versions
interpretation vs. fact
emotional framing
changing meanings
partial memories
contradictions

…the platform becomes the first true system of record for human remembering, not just a scrapbook or journal.

This is the emotional foundation upon which the rest of the product is built.

7. Memory Capture Interfaces, Prompts, Modes & Input Streams

Designing the Seamless, Frictionless, Emotionally Safe System That Pulls Memories Out of People

The most important factor in whether WhatHappened succeeds is not how beautifully it organizes memories — it’s how easily people can get memories into the system in the first place.

Most people:

don’t enjoy writing,
struggle with where to begin,
feel overwhelmed by the idea of capturing their entire life,
or simply don’t have time.

So the system must be designed to make memory capture:

effortless,
natural,
fun,
emotionally rewarding,
guided,
and possible in many different contexts.

This section covers every input mode the platform will support, from high-tech audio capture to simple placeholder entry, along with the prompt engine that powers memory extraction.

7.1. The Five Primary Input Modes

WhatHappened should support multiple ways of capturing memories, because different situations call for different tools. Each mode serves a specific psychological or practical purpose.

Mode 1: Voice Capture (The Primary, Most Human Mode)

Talking is:

faster than typing,
more natural for storytelling,
more emotionally expressive,
closer to how families pass down history.

The system should include:

1. A built-in microphone recorder

press to start
talk naturally
press to stop
instant transcription

Users must also be able to:

play the audio back later
attach it to the memory
make edits to the transcription
keep multiple versions of the same story

2. Smart Audio Prompts

The system can listen and prompt:

“Do you want to add who else was there?”
“Would you like to describe how old you were?”
“Should we tag this memory with your sister Vikki?”

3. Background Audio Capture for Conversations (Memory Nights)

During multi-person sessions, the app can:

record long-form conversation
segment each story into separate memories
transcribe and identify speakers
prompt follow-up questions for each story
send tagged participants a request to add their version

Voice is the emotional heart of memory capture.

Mode 2: Typing / Manual Entry (Classic, But Optional)

Some users will prefer writing, and others will occasionally need it (e.g., editing or adding detail). This mode should feel like:

a simple journal entry
a structured form when needed
or a blank canvas when inspiration strikes

Features:

autosave
markdown or rich-text support
version history
tagging for people, places, themes
date approximations (“I think this was in the late 90s”)

Typing mode supports refinement and detail.

Mode 3: Photo & Video Upload (Visual Memory Anchors)

Photos and videos unlock powerful storytelling.

The system should allow:

uploading individual photos
uploading albums
scanning physical photographs
importing from the camera roll

After upload, AI asks:

“Tell me the story of this moment.”
“Who is this with you?”
“Where was this taken?”
“Do you want to add this to your 1998 timeline?”

Photos become prompts, not just stored media.

Reverse memory lookup:

User can later say:

“Show me every memory with Grandma.”
“Pull up photos from the Lexington house and the stories attached.”
“Find all birthday memories across the years.”

This transforms photos from clutter into a structured narrative tool.

Mode 4: Document Upload & Scanning (Letters, Journals, Recipes, Diaries)

Historical artifacts matter.

Users should be able to upload:

handwritten letters
recipe cards
scanned journals
school papers
military records
certificates
family tree notes
medical or legal documents (optional)

AI then:

OCRs the text
extracts memories
suggests tagged people, places, events
asks for confirmation before creating entries

This allows families to preserve older generations’ materials within the vault.

Mode 5: Placeholder Capture (“Seeds”)

This is critical for memory volume.

Sometimes users remember something but don’t have time to tell the full story.

They need a frictionless way to drop a seed, such as:

“1984 house fire — fill in details later”
“Blue bicycle incident”
“Aunt Marilyn’s peach pie recipe memory”
“That embarrassing moment in 7th grade band”

Placeholders allow:

rapid brainstorming
bursts of memory
later expansion
automatic prompting (“Ready to expand this memory?”)

This is how users can enter hundreds of memories in minutes.

7.2. Additional Capture Modes That Enhance Flexibility

Phone Call Capture (Future Phase)

Users often hear great stories during:

calls with parents
conversations with grandparents
interviews with relatives
spontaneous chats

Eventually, WhatHappened can support:

recording phone calls (with legal disclaimers)
automatic transcription
turning segments into memories
tagging both speakers

This becomes invaluable for legacy building.

Email-to-Memory Ingestion

Users can forward:

long messages
nostalgic emails
written stories
reflections they typed while traveling

The subject line can become the placeholder title.

Integration With Text Messages (Optional Future Feature)

Users could save text threads with:

a parent
a spouse
a friend
a child

…into the vault.

This preserves relationships in real-time and becomes emotionally powerful.

7.3. Guided Prompts & Interview Modes (The Memory Extraction Engine)

The biggest unlock comes from guided storytelling.

Most people won’t remember on their own.
But if prompted, they will.

A. Daily Prompt Mode (“Today’s Memory”)

Users receive:

one carefully chosen prompt per day
tailored to age, season, and already-stored memories

Examples:

“Tell me about a car you loved.”
“Who was your first real friend?”
“What was the best meal of your childhood?”
“What is the earliest memory you have of your mother?”

This builds momentum and habit.

B. Category-Based Prompting

When a user selects a category:

pets
school
vacations
holidays
homes
foods
recipes
sports
music
hobbies

…the system generates prompts to help extract everything in that domain.

C. Life-Phase Prompting

Examples:

“Tell me about your 20s.”
“What was high school like for you?”
“What do you remember about becoming a parent?”

This helps users fill out large empty swaths of their timeline.

D. Memory Nights (Group Prompt Mode)

The system becomes a conversation conductor:

“Everyone share a story about your worst haircut.”
“Tell a memory involving your grandparents.”
“Tell a story from a vacation.”

It also detects when someone is mentioned and prompts:

“Would you like me to ask Vikki for her version of this memory?”

This is fun, social, and massively increases memory volume.

E. Deep-Dive Interview Mode

Users can select modules like:

“My Life Story (guided autobiography)”
“My Childhood”
“My Career”
“Raising My Kids”
“My Relationship With My Parents”
“My Military Service”

Each includes branching interviewer-style prompts.

This produces long-form narrative content.

7.4. AI Assistance During Capture (Without Overstepping)

AI should help, but not overwrite.

AI can:

suggest follow-up questions
detect missing information
identify people or places that should be tagged
summarize long recordings
flag emotional content for additional interpretation
segment memories automatically

AI cannot:

invent factual details
fill in names, dates, places not provided
“fix” a story to be more coherent
merge contradictory versions

This ensures credibility and trust.

7.5. Memory Viewing & Editing (Human-Readable Context First)

Users should always be able to:

see the stored memory in clean, readable narrative form
edit the wording easily
see the attached audio, photos, or documents
modify tags, dates, or participants
toggle between memory versions
add meaning, reflection, or emotional layers

Editing must feel like editing a normal document — not JSON or machine chunks.

Underneath, the system quietly updates the atomic chunks and embeddings.

7.6. Visibility & Awareness: Helping Users See Their Progress

Users need a way to visually understand:

how many memories they’ve added
which life periods are richly documented
which categories are thin
what they should focus on next

The dashboard can show:

a heatmap timeline
category completeness bars
“People density” (which relationships have many stories vs. few)
milestones already captured
suggested next steps

This creates motivation and delight.

7.7. Storage Constraints, Cost Optimization & Technical Considerations (High-Level)

As memories grow, so does storage.

We can plan for:

cheap object storage (audio, images, video)
efficient text indexing
nightly deduplication
tiered quality for audio/video (lower bitrate unless user upgrades)
compression pipelines
cold vs. hot storage (older unused media goes to cheaper classes)

Users adding many multimedia items will likely be on paid tiers, offsetting cost.

Early-stage family-only deployments are inexpensive due to low user counts.

7.8. Why This Section Matters

Memory capture is the front door of WhatHappened.
If this part is effortless and emotionally satisfying, everything else — timelines, multi-perspective memories, AI-generated life stories — becomes possible.

Section 7 defines:

every input stream
every user mode
AI’s role
prompt engineering
and how memories first enter the vault

It is the foundation of the entire ecosystem.

8. Data Modeling & Atomic Chunking

The Invisible Engine That Makes the Memory Vault, Multi-Person Timelines, and the RAG System Work Reliably for Decades

WhatHappened requires an internal data model that:

preserves the human narrative of a story,
supports precise atomic retrieval for AI generation,
links memories to timelines, people, themes, and media,
allows for evolution and multiple perspectives,
and remains durable for 50+ years of a user’s life.

Section 8 establishes the technical backbone that makes this possible.

8.1. Why Atomic Chunking Is Necessary (Even When Storing Full Stories)

We must preserve:

the full narrative version of each story (the user-facing “story layer”),
and a structured, atomic set of smaller memory units (the “AI layer”).

This dual structure allows the system to:

answer questions with precision,
generate summaries,
connect related memories across decades,
support multi-perspective comparisons,
and avoid hallucinating missing details.

So each memory exists at two levels:

1. The Narrative Layer (the original story)

Stored exactly as the user told it — voice, writing, photos, emotion tags, nuance, tone.
This is the user-facing version.

2. The Atomic Layer (chunked memory nodes)

1–3 sentence factual or interpretive units extracted from the story.
These are RAG-friendly units designed for retrieval.

A single story about a childhood fishing trip may generate:

12–20 atomic chunks,
each representing one idea,
tagged with people, places, dates, emotions, categories, and relationships.

This is the same strategy you’ve chosen for Benefits RAG and Agency RAG — and it works beautifully here too.

8.2. The Core Data Object: The Memory Record

Each Memory Record contains:

A. Narrative-Level Fields

Story Title
Full Story Text or Transcript
Audio clips (optional)
Photos / Documents / Videos (optional)
Date or date range
Location(s)
Emotional tags
Perspective indicators (“My version,” “Mom’s version,” “Grandpa’s version told in 1985”)

B. Interpretation Fields

What I believed at the time
What I learned later
How the meaning changed
Confidence level (low, medium, high, reported-only)

C. Metadata

Created date
Last updated date
Version ID
Who contributed this version
Tags (themes, people, categories)
Relationship to other memories (threads)
Whether this is a placeholder or full memory

D. Atomic Chunk Array

A memory contains:

a list of atomic chunks,
each with its own embedding,
metadata,
and relationships to narrative content.

Each memory may produce anywhere from 3 to 40 atomic chunks depending on length and complexity.

8.3. Atomic Chunks: Formal Specification

Each atomic chunk includes:

Chunk ID
Parent Memory ID
Type
- factual detail
- interpretation
- emotional layer
- perspective
- timeline anchor
- relationship note (e.g., “Eric and Vikki remember this differently”)
Text (1–3 sentences max)
People involved
Date or approximate date
Place
Emotional tone
Tags/themes
Confidence level
Whether this chunk contradicts another chunk
Whether this chunk belongs to a specific storyteller

Chunks are built to support retrieval, not to be read directly by the user.

8.4. Multi-Perspective Chunking Model

When multiple people contribute versions of the same story, the system:

1. Creates separate atomic chunk arrays for each person’s version.

2. Identifies overlap, such as:

same event
same location
same people
same outcome

3. Identifies variation, such as:

differences in detail
mismatched time sequences
emotional variations
contradictory interpretations

4. Links chunks together using a “Conflict Graph” or “Variation Map.”

This allows the AI to produce:

“Here’s what Eric remembers.”
“Here’s what Vikki remembers.”
“Here’s what they agree on.”
“Here are the differences.”

This is a major differentiator in the market.

8.5. Linking Memories to People, Places & Categories

Every memory and chunk must be linked to:

People

direct participants
secondary participants
mentioned individuals
narrators
observers

This powers:

the People Map
Life Graphs
multi-perspective comparisons
tagging notifications (“Vikki was tagged in a new memory”)

Places

cities
schools
homes
workplaces
vacation destinations
cars
churches
hospitals
specific addresses (optional)
and generalized place categories

This powers:

maps of where life happened
home-based memory clustering
“Show me all memories from Lexington, Texas” queries

8.6. Modeling Date Uncertainty

A robust system must support fuzzy dates, such as:

“sometime in early 1980s”
“I was in 3rd grade”
“I think I was about 12”
“This happened around 1994–1997”

We store:

1. A primary date (estimated)

2. A date confidence level

3. A date range

The UI displays this gracefully, and the AI uses it cautiously.

This allows timeline visualizations to still function even with incomplete data.

8.7. Memory Threads (Cross-Memory Relationships)

Threads connect memories that share:

people
places
emotions
themes
life transitions
recurring objects (“Grandma’s wooden spoon”)
story arcs (“My relationship with Dad over time”)
repeated events (“All Christmases from 1980 to 2020”)

Threads make the memory vault feel alive and interconnected.

Example thread types:

Identity Threads: “How motherhood changed me”
Object Threads: “My grandpa’s stained-glass workbench stories”
Event Threads: “All my sports injuries”
Emotion Threads: “Moments I felt truly happy”
Location Threads: “The Arlington house memories”

These threads help users see their lives as evolving narratives.

8.8. Versioning Model (Story Evolution Over Time)

There are two version paths:

A. Updated Narratives

Each time the user edits the story, we store:

the new version
a snapshot of the old version
version notes (optional)
timestamps

B. Additional Tellings

When someone retells the same memory years later, this is a new version of the same event, not an edit.

We store these separately but link them as:

alternate tellings
story evolution nodes
emotional evolution

Users can view:

chronological evolution
emotional evolution
differences in detail
differences in meaning

This is extremely powerful for families and future generations.

8.9. How Atomic Chunking Integrates With the RAG System

When a user queries:

“Tell me about my childhood summers.”
“Show me every memory involving my sister.”
“Summarize Grandpa’s time in the Navy.”

…the RAG engine retrieves:

atomic chunks from relevant memories
narrative-level summaries
metadata tags
emotional annotations
timeline anchors
perspective data

This allows responses that are:

factual
personal
non-hallucinated
grounded in the user’s own stories
emotionally accurate
consistent with timeline logic

The narrative layer is then used to reconstruct the storytelling tone.

8.10. Privacy Levels at the Data-Model Level

Each Memory Record and each Chunk inherits or overrides:

visibility settings:
- private
- shared with family vault
- visible to tagged individuals
- public (rare)
sensitivity levels:
- general
- emotional
- trauma
- confidential
- “For my children after I’m gone”

This ensures:

safe storage
respectful AI outputs
controlled access
time-released memories

These rules become part of the data model.

8.11. Why This Data Model Is Transformational

This architecture allows WhatHappened to:

scale to millions of memories
store entire lifetimes
preserve storytelling voice
compare perspectives
avoid hallucination
link memories across categories and decades
generate meaningful summaries
visualize relationships
reconstruct interwoven timelines
build biography-level outputs
integrate world history overlays
support therapy-like reflection
become a true “second brain” for family legacy

This is the foundation of a generational product.

9. UX & Interface Patterns

Designing a Warm, Modern, Memory-First Interface That Feels Effortless, Emotional, and Endlessly Inviting

WhatHappened must evoke feelings of:

safety
nostalgia
emotional warmth
delight
curiosity
ease

Unlike insurance tools or productivity apps, this is a life-story platform.
It must feel personal, human, and beautiful — not clinical.

This section defines the major UX patterns, layout templates, interaction models, and UI metaphors that will shape the entire user experience.

9.1. Design Philosophy

Three principles guide every interface in WhatHappened:

1. Soft Warmth

Visual design should use:

gentle gradients
warm neutrals
nostalgic accent colors (soft blues, sepias, warm golds)
rounded corners
subtle textures reminiscent of photo albums or memory boxes

This avoids the “coldness” of typical tech interfaces.

2. Radical Simplicity

The most common feeling users will have is overwhelm at the idea of storing an entire life.

So the UI must communicate:

“You only need to do one small thing right now.”
“You’re doing great.”
“Just tell me one memory today.”

Avoid complexity. Hide advanced features unless needed.

3. Story-First, Data-Second

We store atomic chunks and machine-readable metadata internally — but the user must never feel like they’re interacting with a database.

The UX must feel like:

a memory journal,
a photo album,
a family story circle,
a visual timeline,
a warm conversation.

The tech disappears behind the emotional experience.

9.2. Home Dashboard — “Your Memory Garden”

The dashboard should feel like entering a personal world.

Key elements:

A. Daily Prompt Card

A large, inviting card at the top:

“Today’s Memory: Tell me about a favorite meal from childhood.”
[Record] [Write] [Skip]

Replacing “add a memory” with “tell a story” is emotionally important.

B. Memory Heatmap Timeline

A visual timeline showing:

which years have many memories
which years are empty
milestones already captured

Clickable to jump into a year.

C. Quick Add Buttons

Record a Story
Upload a Photo
Add a Placeholder
Interview Mode
Memory Night

D. “Recently Added Memories” Carousel

Beautiful cards showcasing recent stories.

E. People Highlights

A rotating display:

“You added 7 new stories involving Mom this month.”

F. Suggested Follow-Ups

“Would you like to finish the memory about the blue bicycle?”
“You mentioned your grandfather’s workshop — want to tell more?”

The dashboard nudges but never overwhelms.

9.3. The Timeline Interface (The Heart of the Experience)

The timeline is the single most important user-facing visualization.

Timeline Core Features:

Scrollable horizontal or vertical mode
Zoomable (decade → year → month)
Memory dots with category colors
Life milestones automatically highlighted
Public world-events overlay toggle (e.g., Reagan elected, Challenger explosion, 9/11, COVID-19)
Event clustering and density visualization
Emotional coloring (e.g., bittersweet episodes shown subtly in tone)

Timeline Navigation Patterns:

Tap a year → see all memories for that year
Tap a memory → open memory card
Long press → add new memory
Pinch → zoom in/out of life periods

It must feel fluid, beautiful, and contemplative — like flipping through a life.

9.4. Memory Browsing Interface (The “Story Cards”)

Each memory should appear as a story card, not a block of text.

Elements of a Story Card:

large cover photo (or abstract memory texture if no photo)
title
date
location
participants (faces or initials)
emotional icons
quick tags

Opening a memory reveals:

the full narrative
audio player (if recorded)
photo gallery
related memories below
meaning layers (interpretation, later understanding)
perspective options (“View Vikki’s version”)
timeline placement
editing tools
privacy settings

Story Card Aesthetic:

Think modern + nostalgic:

muted colors
smooth animations
subtle parallax
typography reminiscent of elegant journals

This is the moment the user feels the emotional weight of their story.

9.5. The People Map UI — “Your Constellation of Relationships”

This must be a signature feature.

Visual Metaphor:

A glowing constellation-style map, where:

each person is a node
closeness = frequency + emotional connection
lines show shared memories
clusters form (family cluster, college friends cluster, coworkers cluster)

Interactions:

Tap a person → timeline + life graph + stories
Pinch to zoom → see clusters
Drag → reorganize custom views
Filter by life period (“Show relationships when I was 15–20”)
Highlight emotional arcs (“Show people connected to my happiest times”)

This becomes both useful and breathtaking.

9.6. Life Graph Visualization (A “Biography Dashboard”)

The Life Graph is a structured overview of one person’s life.

Sections include:

residences (home timeline)
education
jobs/careers
relationships
major milestones
health events
emotional phases
memory density

Visual Style:

horizontal bars
stacked layers
soft colors
icons
click-to-expand sections

AI-Assisted Summaries:

At the top:

“Your 20s were marked by major transitions — new city, first job, and meeting Laura.”

This turns raw data into insight.

9.7. The Memory Capture Interface (Recording, Writing, Uploading)

Capturing a story must feel effortless.

Voice Capture UI:

big circular mic button
wave animation
live captioning
pause/resume
“Add people” prompt
“Add emotions” slider
“Save story”

Writing UI:

distraction-free screen
soft background
“Would you like help expanding this memory?” optional AI suggestions

Photo Upload UI:

After selecting photo(s):

the system suggests a title
asks who is present
asks what’s happening
extracts date/location
prompts for story

Placeholder UI:

ultra-minimal
one field: “Memory seed”
optional tags
3-second save

Users must be able to capture a memory in under 10 seconds.

9.8. Editing Experience (Human-Readable, Never Technical)

Editing must feel like editing a normal story.

Features:

inline editing
audio waveform editing (later version)
photo reordering
add/remove people
correct dates
add meaning layer
add perspective link
save as new version

Internally, this triggers atomic re-chunking — but the user never sees that complexity.

9.9. Family Vault UX Patterns

The Family Vault needs clarity and harmony.

Features include:

each user has their own profile
shared memories show combined perspective cards
everyone can browse overlapping timelines
shared memory suggestions appear
tagging triggers notifications
admins manage membership

UI must feel:

safe
respectful
private
collaborative

Key interface elements:

“Shared With Me” feed
“Add Your Version” button
“Family Timeline Mode” toggle
color-coded people on timeline

Families will love this feature if it feels effortless and emotionally supportive.

9.10. Onboarding UX — The First 10 Minutes

This determines adoption.

The onboarding flow should:

Ask user’s name, birth year, birthplace
Import or ask about life phases
Prompt first memory within 30 seconds
Ask for important people (“Who’s part of your story?”)
Generate first timeline skeleton
Show user their first Life Graph
Give them a daily prompt

By the end of onboarding, the user should already feel:

“I’ve started something meaningful.”

9.11. Emotional UX — Tone, Microcopy & Voice

Every message in the app must feel:

gentle
encouraging
curious
human

Examples:

“You added 3 memories this week — that’s wonderful.”
“Your story matters.”
“Would you like to revisit this later?”
“Tell me more about this — only if you feel comfortable.”

No judgment.
No pressure.
Just invitation.

The platform must be emotionally safe enough that users feel comfortable storing their most vulnerable memories.

9.12. Dark Mode / Comfort Mode

Because users may journal at night or revisit emotional stories, the app should include:

dark mode
sepia mode
soft reading mode

This reduces cognitive strain and deepens emotional engagement.

9.13. The Overall Feel of the Interface

WhatHappened should feel like:

a memory box
a family photo album
a guided autobiography
a story circle
a constellation
a museum of your life

It is not a productivity tool.
It is a deeply personal space.

The UI must reflect that.

10. Tiered Pricing, Subscription Structure & Access Levels

Designing a Sustainable, Ethical, Emotionally-Aligned Business Model for a Generational Product

WhatHappened is not just a SaaS tool.
It is a family legacy system — something personal, emotional, multi-generational, and deeply meaningful.

The business model therefore must be:

fair (not exploitative of emotional needs),
transparent,
scalable,
predictable,
aligned with natural user psychology,
and built to support 50+ years of usage.

This section defines the pricing architecture that encourages users to start small, grow naturally, and eventually adopt full family-level participation.

10.1. The Psychology of Pricing WhatHappened

Most users will experience one of these emotional triggers:

1. Nostalgia

They want to remember more.

2. Fear of Loss

They want to preserve stories from aging parents and grandparents before those memories disappear.

3. Legacy

They want their children and grandchildren to know them.

4. Connection

Family members want a shared space to understand each other.

5. Organizing Overwhelm

They need a better place to store life’s photos, memories, stories.

6. Curiosity / Fun

Timeline games and world-event overlays pull them in.

Pricing must lower barriers during early adoption, then scale with user commitment.

10.2. The Four-Layer Monetization Framework

WhatHappened includes four distinct revenue layers, each aligned with a natural upgrade path:

Layer 1: Public Timeline & Free Account (Top of Funnel)

This is where mass adoption begins.

Free Tier Includes:

Full access to the public timeline (world events, prices, culture, music, movies, cars, politics, historical anchors).
The Public Timeline RAG (“What happened in 1985?”)
Ability to save a single memory (“Try it—add your first memory”).
Ability to store up to 10 placeholder memories.
Ability to invite one other person to compare versions of a single shared story (a “teaser”).

Purpose:

Build trust.
Give users a taste of magic.
Encourage people to begin capturing before something important is forgotten.
Create natural upsell points (“Want to save more than 1 story?”).

Conversion Expectation: ~15–25% will upgrade.

Layer 2: Individual Plan (Core Subscription)

This is the core revenue engine. Most users start here.

Individual Plan Includes:

Unlimited memories
Unlimited placeholders
Unlimited photos, audio, and documents (fair usage limits apply)
Full personal timeline
Life Graph
People Map (single-user view)
Daily prompts
Interview Mode
Ability to build timelines for two additional people (e.g., mom and grandma)
Multi-device sync
Export options for personal backup (text + media archive)

Ideal Pricing:

$7–12/month
or
$70–99/year

This is emotionally acceptable because it’s seen as preserving something priceless.

Layer 3: “Build Their Story” Add-On (Advanced Timelines for Non-Users)

For users who want to document the lives of parents, grandparents, children, and ancestors without those people needing an account.

Add-On Includes:

Unlimited additional People Profiles
Unlimited non-user timelines
Ability to upload letters, photos, journals for other people
Timeline reconstruction tools
Ancestry mode (import data, obituaries, research)
Multi-perspective captures even when the individual does not log in
“Interview Packs” — guided templates for interviewing older family members

Pricing:

$4–6/month
or
$40–50/year

Why this matters:

Many families will want to build timelines for 5–20 relatives.
It prevents account-sharing confusion.
It generates stable revenue from hyper-engaged users.

This is extremely high-margin and a strong revenue driver.

Layer 4: Family Vault (Premium Plan)

This is the ultimate experience — one shared family universe.

Family Vault Includes:

Up to 6 individual logins
Combined Family Timeline
Multi-perspective memory comparisons
Family Memory Nights Mode
Shared AI assistant trained on only that family’s vault
People Map with overlapping relationship webs
Story stitching (“Generate the combined family version of Christmas 1994”)
Group subscription billing
Legacy Mode (“Release this story to my family after I’m gone”)

Pricing:

$18–25/month
or
$180–240/year

Why families upgrade:

Triggered by births, weddings, deaths, holidays, reunions
Emotional bonding
Collaborative storytelling
Parents capturing for kids
Multi-generational benefits

This is the “forever subscription” layer.

10.3. Additional Monetization Options (Ethical & Optional)

These are never required. They enhance the experience for serious memory-keepers.

A. Cloud Storage Add-Ons (For Heavy Photo/Audio Users)

After a generous base allotment (e.g., 50GB):

+100GB
+500GB
+1TB

Memory-heavy families will pay for this gladly.

B. Time-Release Legacy Packages

These allow:

stories to be unlocked after death
messages for future birthdays
“Open this when you turn 18” letters
recorded audio for grandchildren

Pricing would remain low and ethical — this is emotional territory.

C. Printed & Hardcover Memory Books (AI-Generated)

The system can generate:

“My Life Story”
“Stories of Grandma Jane”
“The Smith Family History”

Users can order high-quality printed books.

Profit margin is excellent.

D. Memory Video Production (AI + Human Hybrid)

Users could upgrade for:

narrated story videos
animated story recreations
video timelines
slideshow reels

Think “legacy documentaries.”

E. Event Packages (Wedding, Birth, Memorial)

These provide:

tailored prompts
story bundles
guest submissions
memory timelines for a major event

This becomes a major marketing avenue.

10.4. Ethical Pricing Guidelines (Non-Negotiable)

Because this product touches emotional and sensitive content, the business must:

Never hold memories hostage.
Export is always available.
Never charge for access to memories after a death.
Family survivors get guaranteed read access.
Never upsell during moments of grief or trauma.
Always provide a low-cost option for seniors capturing life stories.
Offer discounts for multi-year subscribers.

This maintains trust for a multi-decade product.

10.5. Natural Upgrade Path (The Behavioral Funnel)

The ideal customer journey looks like this:

Step 1: Free Timeline Visitor

Visits out of curiosity → plays with world events.

Step 2: Free Account

Adds 1–2 memories → gets hooked.

Step 3: Individual Plan

Begins capturing seriously.

Step 4: Add-On: Build Their Story

Starts documenting parents → highly emotional.

Step 5: Family Vault Upgrade

Siblings join → multi-perspective memories emerge.

Step 6: Storage Add-On

As photo/audio library grows.

Step 7: Physical Books & Legacy Products

The family wants tangible keepsakes.

This produces:

strong retention
extremely high LTV
predictable recurring revenue
viral loops inside families

10.6. Why This Pricing Structure Works

It aligns with:

psychology (nostalgia → storytelling → legacy → collaboration),
behavior (from individual to family),
data usage levels (storage increases over time),
emotional value (stories are priceless),
and scalability.

Most importantly, it avoids manipulative pricing and instead supports meaningful, life-affirming use cases.

11. Technical Architecture & Infrastructure Blueprint

A scalable, multi-layer system designed for decades of memories, multi-generational storytelling, and AI-powered retrieval

The architecture must satisfy five competing needs:

Simplicity at launch (small user base, low cost, rapid iteration).
Massive long-term scalability (millions of users, billions of memories).
Media-heavy storage (photos, documents, audio, video).
AI-powered retrieval with extremely high accuracy (RAG).
Strict privacy boundaries (memories are sacred; leakage is unacceptable).

This section lays out a multi-phase architecture that ensures you can launch fast, test the concept, onboard your family, then grow into a real consumer product without rebuilding everything from scratch.

11.1 Core Architecture Philosophy

The WhatHappened system is built on four guiding principles:

1. Modular, not monolithic.

Each subsystem (storage, RAG, transcription, timeline engine, user accounts) is separated, so any component can be upgraded later without breaking the entire app.

2. “Stateless front-end, stateful vault.”

The UI should be lightweight; all memory lives in the structured, secure backend vault.

3. “Your family is your universe.”

Every family vault is a sealed, fully isolated data container.
Nothing ever blends across families.

4. “Cold storage by default.”

Media library (photos, audio, videos) is stored cheaply until needed; RAG only indexes text, not raw media files — keeping costs manageable.

11.2 The Five-Layer System Architecture

The full system consists of these major layers:

Layer 1: Front-End Interface (UI/UX Layer)

Where people add, view, edit, and play with memories.
Built with modern front-end frameworks:

React (ideal for a long-term product)
Next.js (SSR, SEO-friendly, scalable routing, ideal for timeline views)

Front-end communicates with all backend services through an authenticated API gateway.

Key experience components:

Memory Capture screen
Placeholder capture
Audio recorder screen
Photo/document upload
Timeline browser
People Map
World Timeline Overlay
Memory Night Mode
Gamification widgets
AI storyteller
Edit & version-history panel

No memory logic lives here; the front-end simply sends requests to backend microservices.

Layer 2: Application Layer (API + Microservices)

This is the brain of the system, built as either:

serverless functions (AWS Lambda / Google Cloud Functions) for early stage
or
Dockerized microservices for scale.

Recommended early architecture:

Microservices include:

Memory Service
- Create/edit memories
- Link memories
- Merge versions
- Manage placeholders
- Manage categories & tags
Media Upload Service
- Stores files
- Generates thumbnails
- Performs virus scanning
- Handles audio → transcription pipeline
Timeline Service
- Render personal timeline
- Render family timeline
- Generate date ranges
- Align memories with public world events
People Service
- Profiles for the user and non-user relatives
- Relationship linking
- Age calculations
- Timeline overlap logic
Gamification/Prompts Service
- Daily memory prompts
- Family Night prompts
- Trivia & games
- Seasonal memory themes
RAG Retrieval Service
- Embedding
- Indexing
- Query routing
- Family-specific RAG logic
- Safety/permission layers
Auth & Billing Service
- Logging in
- Family vault membership
- Subscription management
- Role-based access

All communication occurs through a secure API gateway.

Layer 3: Data Layer (Databases & Storage)

This is the heart of WhatHappened.

We need extremely scalable, low-latency, low-cost storage for:

Text memories
Timelines
Relationships
Tags
Media files
Embeddings
Permissions
Audit logs

Recommended Data Stack

A. Primary Database: PostgreSQL

Stores:

memory records
metadata
users
people profiles
relationships
timelines
version history

Why PostgreSQL?
It’s relational, supports complex queries, scales well, and is future-proof.

B. Document Store (Optional for Scale): MongoDB or Firestore

For:

JSON memory objects
Large or nested metadata
Flexible schema evolution

C. Vector Database: Pinecone or Weaviate

For all embeddings:

Memory chunks
People summaries
Story summaries
Placeholder concepts

Each family is its own namespace, isolating their data from everyone else.

D. Media Storage: AWS S3 or Google Cloud Storage

For:

photos
scanned letters
PDFs
voice recordings
video clips

Cold storage tiers keep costs extremely low.

Layer 4: AI Services Layer

This is where the magic happens.

Core AI functions:

1. Transcription

Using Whisper (OpenAI) or AWS Transcribe.

2. Chunking Pipeline

Breaks memories into atomic chunks:

single idea
clean text
metadata attached
semantic tags

3. Embedding Pipeline

Uses high-quality embeddings (OpenAI, Cohere, or local models).

4. Retrieval & Ranking Engine

Searches across:

personal memories
family memories
public timeline
world events
cross-person links

5. Story Reconstruction Engine

Combines memories into:

stories
summaries
stitched narratives
multi-perspective reconstructions

6. Prompting Engine

Generates:

new questions
interview prompts
follow-ups
daily nudges

7. AI Editing & Rewrite Engine

Allows:

grammar fixes
enhancement
voice preservation
version comparison

Every family vault uses a unique retrieval pipeline.
Your memories never mix with anyone else’s.

Layer 5: Security, Privacy, & Identity Layer

Given the deeply personal nature of memories, the system must be ultra-secure.

Security Principles:

Zero-trust authentication
Fully isolated family vaults
Encrypted at rest & in transit
No cross-family RAG contamination
Access logs for all AI interactions
Multi-factor authentication
Data residency controls
Disaster recovery redundancy

Privacy Principles:

Users own their data
Export anytime
Survivors get guaranteed access
“Never used for model training”
“We don’t sell your data”

WhatHappened must be one of the most trustworthy products on the internet.

11.3 Launch Phase vs Scale Phase

Launch Phase (Family Beta, 10–50 users)

Use:

Supabase or Firebase for auth + database
Cloud storage buckets
Pinecone Starter Tier
Serverless functions
Simple Next.js front-end
Whisper API for transcription
OpenAI for RAG + retrieval pipeline
Manual cron jobs for prompts

Scale Phase (1,000–1,000,000+ users)

Upgrade to:

Multi-region PostgreSQL (Aurora or Spanner)
Dedicated vector DB cluster
K8s microservices
CDN for media delivery
Automated scaling pipelines
Full Observability stack
Automated embedding + indexing pipelines
Family vault sharding for performance

11.4 Storage Cost Analysis

Photos

~1–5 MB each
Average user stores 10–100 per year
Cold storage reduces cost to $0.005–0.01/GB per month.

Audio

~0.3–1.5 MB/min
Most memory captures 1–5 minutes
Very inexpensive.

Video

Users will not upload much video (expensive).
We can limit video length at launch to control cost.

Total expected cost per user (first year):

$0.25–$1.75 per user per month at small scale.
This falls dramatically as you scale.

This is why storage add-ons are a profitable upsell.

11.5 Multi-Tenant Architecture (Family Vault Isolation)

Each family vault operates like a mini-database:

separate namespace
separate permissions
separate RAG index
separate People Map
separate timelines

This prevents:

accidental mixing
privacy breaches
retrieval contamination
“one user seeing another family’s memories” (catastrophic)

This is the most important architectural design decision, and you’re doing it correctly.

11.6 Where the Memory Data Actually Lives

Every memory has three representations:

1. Raw Input

The exact words the user spoke or typed.
Stored permanently.

2. Cleaned / Chunked Version

Used for retrieval, tagging, story generation.

3. Embedded Version

Vector used for semantic search.

The raw version is never overwritten — users may update their memory, but the original always exists in version history.

11.7 Tech Stack Recommendation Summary

Front-End

Next.js (React), Tailwind UI, shadcn components

Back-End

FastAPI or Node.js microservices
Serverless for alpha/beta

Database

PostgreSQL + optional MongoDB

Vector DB

Pinecone or Weaviate

Storage

AWS S3 (cold storage tiers)

AI

Whisper for transcription
OpenAI for generation & RAG
Fine-tuned models later

12. User Interface Framework & Mockup Overview

The visual and interactive backbone of WhatHappened — how users capture, browse, relive, and co-create their life stories.

The UI/UX of WhatHappened must evoke warmth, nostalgia, simplicity, and zero friction, while still offering deep capability. It cannot look like “a tech app.” It should feel like a digital memory book that happens to have superpowers.

Below is the system-wide UI framework, core screen inventory, navigation patterns, and mockup-style explanations of how each feature works.

12.1 Guiding UI/UX Principles

1. “Capture first, perfect later.”

Make memory capture instant, with editing optional.

2. “Everything visible, nothing overwhelming.”

Users see a gentle overview of their memory universe, not walls of text.

3. “Warm, human, joyful.”

Typography, color palette, and layout evoke safety, nostalgia, and comfort.

4. “The interface should spark memories.”

Timeline views, categories, photos, and prompts should trigger recall.

5. “Always know what to do next.”

Every screen gently nudges the user toward capturing more memories.

12.2 Core Navigation Structure

The main app UI is organized into five primary tabs (mobile-first), plus contextual overlays.

Bottom Navigation (Primary)

Home / Dashboard
Capture (microphone + quick-add button)
Timeline
People
Vault (Library)

Top Navigation (Secondary)

Settings
Family Vault Switcher
Prompt Queue
Notifications (tags, comments, contributions)

Context Panels

Memory Editor
Photo/Media Viewer
Story Builder
AI Suggestions
Multi-perspective Viewer

12.3 Screen-by-Screen Overview (Core Experience)

12.3.1 Home / Dashboard

Purpose: Provide a landing page that feels calm, welcoming, and inspiring.

Key elements:

“Good evening, Eric. Ready to add a memory?”
Daily Prompt Card (“Tell me about your first car”)
Recently Added Memories (carousel)
Suggested Additions based on timeline gaps
Family Activity (optional)
Upcoming anniversaries, birthdays, milestone events

Behavior:
Everything on the dashboard is tappable — one click opens a memory, a prompt, or a category.

12.3.2 Capture Screen (The Most Important UI in the App)

This must be frictionless — the place where 80% of memories enter the system.

Capture Modes:

Voice → Transcription
Text Entry
Photo + Caption
Audio Upload
Document Upload
Placeholder (“Title only, fill later”)

Example layout:

A large, round Record button at the center (voice capture).
Below it:

“Type instead”
“Add photo”
“Add placeholder”
“Upload file”

Post-Capture Flow:

After a recording or typed memory is submitted, a soft modal appears:

“Would you like WhatHappened to help structure this memory?”

Options:

Keep exactly as spoken (story mode)
Clean lightly
Add tags & categories
Save raw

This ensures voice preservation for storytelling memories.

12.3.3 Placeholder Capture UI

A simple input box labeled:

“Quick note or title to fill in later:”

Underneath:

Suggested tags
Suggested related categories
“Remind me next week to fill this in”

This screen enables users to capture a flood of triggers without bogging down.

12.4 Browsing & Re-living Memories

Now we transition from capture to navigation.

12.4.1 Timeline Screen (Horizontal Scroll + Vertical Zoom)

Two-layer timeline:

Personal Timeline → life events
World Timeline Overlay → context

Users can:

scroll horizontally through decades
pinch-to-zoom for detail
tap “show events for this year”
filter by category, person, emotion, or memory strength

Memory Cards on Timeline:

Floating cards appear along the timeline:

photo thumbnail
title
short excerpt

Tapping opens the memory viewer.

12.4.2 Memory Viewer

This is the storybook page of the app.

A memory is displayed as:

title
date(s)
categories
tags
story text (raw or cleaned)
photos, audio, attachments
versions
related memories
branch points (where interpretations differ)

Toolbar:

Edit
Add perspective
View other perspectives
Link to another memory
View story arc

This is also where the user sees AI-generated enhancements but only if they request it.

12.4.3 Multi-Perspective Memory Viewer

A swipeable interface:

“Eric’s version” → swipe → “Vicki’s version” → swipe → “Grandpa’s version (1988 recording)”

Each version’s differences may be highlighted with gentle color coding (optional).

12.5 The People Map

The People tab is a network view of everyone important to the user.

Each person has:

Photo/avatar
Lifespan or current age
Relationship
Timeline
Memories involving them
Stories they’ve told
Stories told about them
Categories (work, childhood, school, etc.)

Features:

Tap to open their profile
View overlapping timeline with the user
“Add a memory about this person”
“Interview this person” (prompt list + voice capture)

This is how users capture memories about grandparents, parents, friends, even deceased relatives.

12.6 The Vault (Library)

This is the filtering and browsing powerhouse.

Filters include:

date range
category
tag
location
people involved
memory type (story, snippet, placeholder, audio, photo, recipe, etc.)
perspective (mine vs others)
emotions
life period (childhood, young adult, etc.)

A user can also save custom views:

“My childhood homes”
“Mom stories”
“All prom-related memories”
“Trip to Mexico 2018”

12.7 Contribution & Tagging Flows

Tagging others:

When a user tags someone in a memory:

“Notify Vicki that she is part of this memory?”
If yes, she gets:

“You were tagged in a memory. Do you remember it? Add your version?”

Contribution UI:

Shows:

Pending contributions
Memories waiting for your perspective
Suggested memories from others

12.8 Gamification & Play UI

Gamification must feel natural, nostalgic, and meaningful — not childish.

Gamification Screens Include:

1. Memory Night Mode

A large-card prompt sequence:

“Tell a story about a time you were completely surprised.”
“Who taught you to drive?”
“What was your favorite Thanksgiving?”

Tap to record.
Group mode allows multiple perspectives back-to-back.

2. Trivia Mode (Shared or Solo)

Questions:

“What song was #1 when this memory happened?”
“Which year did the house on Lexington burn down?”
“Who else was present for this event?”

This triggers memory recall and learning.

3. Timeline Fill-In Bingo

Users see gaps on their timeline:
“Between 1986–1989, few memories exist. Add one?”

12.9 Editing & Version Control UI

Editing must be simple and safe.

Memory Edit Panel:

inline editor for text
photo reorder
attach new media
correct dates
change categories
mark as “story (voice preserved)”
mark as “non-story snippet”

Version History:

A sheet opens showing:

Original capture
Cleaned version
Edited version
Story-preserved version
AI-suggested enhancements

Users can restore any version with one tap.

12.10 AI Helpers Embedded in UI (Optional, Always Permission-Based)

Embedded AI tools include:

“Summarize memory”
“Enhance clarity while preserving my voice”
“Suggest tags & categories”
“Find related memories”
“Generate a stitched story with multiple perspectives”
“Rewrite this in my childhood voice / adult voice / storyteller voice (only if requested)”

AI never edits automatically — only when invited.

12.11 Visual Identity Guidelines

The app needs to feel like:

warmth
trust
nostalgia
family
personal significance

Recommended palette:

Creams
Soft browns
Dusty blues
Muted greens
Warm grays

Typography:

Serif font for story text (feels like a memoir)
Sans-serif for UI labels

Animations:

Gentle fades
Slow transitions
Soft parallax for timelines
No harsh movement

12.12 Prototype Flow Summary

A new user’s first 60 seconds:

Sign up → Create personal vault
Add first memory with voice
See timeline appear with one event
System suggests 3 prompts
See placeholder section
Invite a family member (optional)
Add a photo
Receive “Welcome to WhatHappened, Eric” message

This immediately shows value.

13. Data Model & Schema Design

The structural engine that powers memories, timelines, people, perspectives, and retrieval.

The WhatHappened system needs a flexible but rigorously defined data model that can:

Store raw memories (voice, text, media)
Store cleaned/edited versions
Preserve the original storyteller’s voice
Connect memories across people, dates, categories, and events
Handle timelines with uncertain or partial dates
Link multiple perspectives of the same event
Support placeholders and incomplete entries
Handle contextual overlays (world events, cultural data)
Support future AI-driven retrieval and stitching

This section defines the architecture in a way that engineers can implement and RAG systems can use reliably.

13.1 Core Objects and Their Purpose

At the heart of the system are seven primary data objects:

Memory (the core unit)
Memory Version (story mode, cleaned mode, edited mode, etc.)
Placeholder (future-memory stub)
Person (user + every person referenced)
Media (photos, videos, audio files)
Timeline Event (personal or global)
Perspective Link (connects multiple perspectives of the same event)

These objects interlock to form a memory graph — not just a list.

13.2 Memory Object (The Central Node)

Each Memory object represents a single captured remembrance — whether a story, snippet, or a three-sentence recall.

Memory Fields

memory_id (UUID)
owner_id (person who submitted it)
primary_subject_person_id(s)
(who the memory is about — could be self or others)
title
description / raw_text (initial capture)
memory_type
- story (preserve voice)
- snippet
- audio-first (voice-only)
- photo-first
- recipe
- dream
- factual log
- placeholder-converted
dates:
- when_it_happened_start
- when_it_happened_end (optional range)
- when_it_was_told
date_confidence (exact, approximate, estimated)
location(s)
tags (emotion, theme, objects)
categories (homes, school, work, vacations, pets, food, relationships)
involved_person_ids (others present)
media_ids
related_memory_ids (other memories linked)
world_event_ids (automatic contextual links)
strength_score (user- or AI-assigned significance)
visibility:
- private
- shared vault
- specific people

Key Points

Memories support multiple time associations: when told vs. when lived.
Memories can involve multiple people, not just the creator.
All time fields allow approximate input (“1980s”, “summer 1992”).
Tags and categories support RAG retrieval and browsing.

13.3 Memory Version Object (Preserving Voice & Edits)

Every memory can have many versions, because users may:

record a raw voice narrative
get a cleaned version from AI
edit the text later
rewrite parts
convert a placeholder into a full story

Fields

version_id
memory_id
version_type
- raw
- transcript
- cleaned
- story-preserved
- edited
- AI-enhanced (optional)
text_content
media_alignment (timestamps, attachments)
created_at
editor_id
notes (what changed and why)

Behavior

Memory Versions form a chronological stack.
Users can revert to any version.
RAG has rules:
- Story-preserved versions are used for storytelling output.
- Cleaned/edited versions are used for factual lookup.

13.4 Placeholder Object (Trigger For Future Capture)

A placeholder is a lightweight object that holds only the seed of a memory.

Fields

placeholder_id
owner_id
title / trigger text
suggested categories
suggested tags
created_at
converted_to_memory_id (nullable)

Behavior

Stored separately from Memories for clarity.
Appears in “Unfinished Memories.”
System periodically suggests:
“Ready to tell the story behind this?”

13.5 Person Object (Not Just Users!)

Every individual referenced needs a Person object, even if they:

do not have an account
are deceased
appear only in stories

Fields

person_id
full_name
nickname
born / died / unknown
relationship_to_user
roles in memories (e.g., parent, teacher, coworker)
profile_photo_id
notes / bio
timeline events auto-generated from memories

Behavior

Users can build a complete timeline for someone else — e.g., a parent or grandparent — without that person being a subscriber.
Each Person gets an automatic life timeline built from:
- memories about them
- tagged locations
- photos
- known events

13.6 Media Object (Photos, Video, Audio, Docs)

Media files must be stored and indexed properly.

Fields

media_id
file_url
file_type (jpg, mp4, mp3, pdf)
thumbnail_url
captured_date
created_at
attached_memory_ids
caption
EXIF location (optional)

Behavior

One media file can link to multiple memories.
Media can be browsed by:
- timeline
- category
- person
- trip
- home

13.7 Timeline Event Object (Personal, World, & Family Combined)

There are three kinds of timeline events:

Personal events (from the user’s memories)
Family events (births, deaths, moves, marriages)
World timeline events (public reference data)

Fields:

event_id
event_type (personal, family, world)
title
description
date_start
date_end
associated_person_ids
associated_memory_ids
world_event_tags (music, politics, film, sports)

Behavior:

A memory automatically generates a personal event.
A tagged person may auto-generate life milestones.
World timeline events anchor memories in cultural context.

13.8 Perspective Link Object (The Multi-Version Story Engine)

This object links multiple memories that represent:

different recollections of the same event
different storytellers describing a shared experience
conflicting accounts
humorous exaggerations over the years

Fields:

perspective_id
canonical_event_id (optional; a shared “parent event”)
linked_memory_ids (multiple)
notes (“Eric’s version differs in this detail…”)

Behavior:

Swapping between perspectives is instant.
RAG can answer questions like:
“How did each person remember this differently?”

13.9 Relationship Graph (Underlying Everything)

The system uses a relationship graph to connect:

memories ↔ people
memories ↔ events
memories ↔ media
people ↔ timelines
perspectives ↔ canonical events
placeholders ↔ future memories
world events ↔ personal memories

This graph enables:

RAG retrieval
deep search
similarity matching
reconstruction of autobiographies
reconstruction of family trees
multi-perspective story stitching

13.10 Data Storage Strategy (Scalable, Affordable, Flexible)

Short-term (early family-only stage):

Supabase or Firebase Postgres
Cloud storage for media (Backblaze B2, AWS S3, or Supabase Storage)
Vector embeddings stored in pgvector or Pinecone (starter tier)
Extremely low cost up to dozens or hundreds of users

Long-term scaling:

Partitioned Postgres or DynamoDB
Dedicated vector store (Pinecone, Weaviate, Milvus)
CDN-based media delivery
Multi-region replication
Eventual SSO + account linking for family networks

Costs scale primarily with media (photos/videos).
Text storage is negligible.

13.11 RAG Pipeline Dependencies

Objects must store what the RAG needs:

narrative text (story-preserved)
factual text (cleaned/edited)
tags, categories, metadata
time anchors
person relationships
embeddings per version

The RAG workflow will:

Retrieve memories by semantic meaning
Use metadata filters (person, date, emotion, etc.)
Select the appropriate version (story vs factual)
Stitch output as needed
Reinforce timelines and connections

13.12 Extensibility for Future Features

Because of the schema flexibility, we can later add:

memory strength modeling (like Ebbinghaus forgetting curve in reverse)
ancestry overlays
AI-generated life maps
shared couple timelines
memory “clusters” that generate chapters of a memoir
audio storybooks
automated video montages

Nothing in the model restricts future innovation.

14. Privacy, Security & Access Control Architecture

Protecting the most intimate data users will ever store — memories, stories, relationships, and personal history.

WhatHappened will contain highly sensitive information: childhood memories, family history, personal interpretations of events, private audio, and more.
Therefore, security, privacy, and granular access control cannot be bolted on later — they must be foundational.

This section defines:

Privacy philosophy
Roles and access levels
Vault design
Encryption
Sharing rules
Family networks
Legal considerations
“Memory inheritance” for future generations
Data portability
Long-term survivability

14.1 Core Privacy Philosophy

The system follows four pillars of trust:

1. You own your memories.

Not the company.
Not advertisers.
Not AI models.
Not a social network.

2. Your vault is private by default.

Nothing is shared unless the user explicitly opts in.

3. You control what others can see.

Granular visibility levels for each memory.

4. AI only uses what you permit.

Your memories are used only for retrieval and storytelling inside your vault — never for model training without explicit permission.

14.2 Access Control Model (Owner → Family → Guests → Viewers)

There are four levels of access, each with their own permissions.

Level 1: Owner (Full Control)

The person whose vault it is.

Permissions:

create, edit, delete memories
upload photos, videos, audio
manage placeholders
tag others
define privacy for each memory
create secondary vaults (e.g., parent timeline, grandparent life story)
invite family members
approve or reject contributions
view all analytics, timelines
export data

Level 2: Family Contributors (High Trust)

Family members who can add memories but cannot edit or delete the owner’s.

Permissions:

add memories related to the owner
add memories about themselves
add memories about shared people (e.g., parents, grandparents)
add multiple perspectives
upload media
see memories marked “Family-visible”
cannot see “Private” or “For my eyes only” memories
cannot edit the owner’s text or replace versions
cannot delete memories they didn’t create

This is ideal for siblings, partners, cousins, adult children, etc.

Level 3: Tagged Contributors (“Memory Guests”)

These are people who were part of specific memories but are not full family participants.

They can:

view only the memories they were tagged in
add their perspective to that specific memory
cannot see anything else
cannot browse the vault
cannot see timelines

Example:
Your childhood friend contributes their version of a story.

Level 4: Read-Only Viewers

People who are allowed to see certain memories, like:

memories shared in a wedding montage
recipes shared with extended family
a curated set of stories intended for friends

But they cannot:

browse the vault
view timelines
see private categories
see media unless manually authorized

14.3 Memory-Level Visibility Rules

Every memory has a visibility setting:

Private (only me)
Family (family contributors)
Specific People (granular list)
Public Story (optional for legacy publishing)
Invisible (hidden but retrievable by AI for me only)

This allows:

hiding traumatic memories
storing therapy insights
writing things that are not shareable now but may be later
preparing autobiographical content separately

14.4 Vault Architecture (Private, Shared, Linked)

There are three vault types:

1. Personal Vault

Every subscriber has exactly one main vault.

Contains:

personal memories
placeholders
categories
timelines
recipes
dream logs
interpretations
audio notes

2. Family Vault (Linked Accounts)

A shared vault containing:

overlapping timelines
stories told in family gatherings
shared photo albums
group memories

Each member has their own private space AND access to the shared space.

This supports:

couples
siblings
parent-child relationships
multi-generational networks

3. Ancestor/Legacy Vaults

Users can create vaults for:

their parents
grandparents
deceased relatives
historical family figures

These vaults:

are editable only by the user
can be merged into shared family vaults
allow “family biography reconstruction”
can be left as a legacy for descendants

14.5 Encryption Strategy

Encryption in Transit

HTTPS/TLS 1.3
End-to-end encryption for sensitive transmissions (voice uploads, personal memories)

Encryption at Rest

AES-256 server-side encryption
Optional client-side encryption for “Private” memories
(meaning even WhatHappened staff cannot view them)

Key Management

Using AWS KMS or Google KMS
Rotating keys automatically
Separate keys for:
- personal vault data
- media
- placeholder data
- RAG embeddings
User-held encryption key for “for my eyes only” category (advanced tier)

Media Encryption

Photos, videos, audio are encrypted individually, not just by bucket-level rules.

14.6 RAG Privacy Controls

RAG must only retrieve memories the user is allowed to see.

Rules:

The embedding store respects memory visibility.
Private memories produce embeddings stored in a private vector space.
Family memories are stored in a family-only vector index.
No cross-user retrieval unless specifically shared.

Optional Future Feature:

For couples or families, shared RAG where:

RAG retrieves memories from both partners
but never from private categories

14.7 AI Model Privacy

AI never:

trains on private user data
stores prompts for external training
uses memories to benefit other users

AI can, only with permission:

learn the user’s storytelling voice for personalization
learn writing style patterns
learn emotional tone

This “voice model” is stored per-user and only in their encrypted vault.

14.8 Authentication & Identity Security

Options:

password + MFA
passkeys
biometric unlock on mobile
device-level tokens

Additional Protections:

suspicious login warnings
login attempt throttling
device history
optional IP-based restrictions

14.9 Backup, Redundancy & Digital Permanence

WhatHappened must outlive:

broken phones
lost passwords
cloud outages
company transitions
future decades of new technology

Backup Policy:

daily automated backups
encrypted off-site storage
multiple zones and availability regions
continuous media backup

Disaster Recovery:

RPO under 24 hours
RTO under 3 hours
Hot failover for the database

Long-Term Vision:

A “Forever Library” mode where a family can prepay for 50 years of archival storage.

14.10 Memory Inheritance (Passing Stories to the Next Generation)

Users can specify:

who inherits their vault
who inherits specific memories
which memories should remain private permanently
which can be opened after death
which are never to be shared (encrypted black box)

This is similar to digital estate planning but focused on stories.

14.11 Legal & Ethical Safeguards

Compliance Considerations:

GDPR
CCPA
Personal Data Protection for minors
Data deletion rights (“right to be forgotten”)
Exportability (PDF, JSON, or multimedia bundles)

Ethical Safeguards:

Transparency about what AI is doing
Clear consent tracking
Handling memories involving other people respectfully
Tools for reporting inappropriate or harmful content

14.12 Data Portability & Export Formats

Users must be able to export:

entire vault
selected memories
timeline reports
cookbook of recipes + associated stories
family biographies
memory stories for funeral/memorial services
life chapters for book generation

Export formats:

PDF
HTML
JSON
Audio collections
Memory albums

14.13 Long-Term Survivability & Future-Proofing

The system is designed for decades of use.

Future-proof elements:

modular schema
upgradeable AI models
migration scripts for new database technologies
ability to re-process embeddings
format-neutral media storage
clear API for exporting/importing vaults

If WhatHappened is ever sold or merged:

users retain control
users retain data ownership
vaults remain encrypted
data portability guaranteed

15. Pricing Tiers, Monetization Strategy & Upsell Architecture

A sustainable, scalable business model built on emotional value, network effects, and deep retention.

WhatHappened will attract two kinds of people:

Individual users who want a private memory vault.
Families who see this as a long-term shared storytelling platform.

Our monetization strategy must support both, while keeping the free experience irresistible and the paid experience indispensable.

15.1 Business Model Overview

The WhatHappened platform will generate revenue through eight channels:

Subscription tiers (core revenue)
Family plans
Legacy & Estate plans (“Forever Vaults”)
AI-powered memoir creation (premium add-on)
Photo/video digitization partnerships & upsells
Printed storybooks & coffee-table albums
Transcription packages
Bundling with Idea Vault (“Your past + your future”)

This diversified model ensures longevity and stable recurring revenue.

15.2 Tier Structure (Free → Premium → Family → Legacy)

Here are the four main tiers:

Tier 0: Free Plan (The Gateway Product)

Purpose: Build trust, emotional attachment, and viral adoption.

Included:

Access to the public timeline
Daily memory prompts
25 memories stored (text only)
10 placeholders
5 photos
5 minutes of audio transcription
AI retrieval limited to “Your 25 memories only”
Export basic PDF of your stored memories
Ability to upgrade any time

Why Free Works:

Think of it like 23andMe: people get addicted once they see value.
Memories are emotionally sticky — users will upgrade once they hit limits.
Free users provide viral loops (“tag a friend,” Memory Night invitations, etc.)

Tier 1: Premium Personal Vault ($8–$12/mo)

Target: Individuals wanting to preserve their life story.

Features:

Unlimited memories (text, photos, audio, video)
Unlimited placeholders
Unlimited timelines
Full AI retrieval across all personal memories
AI story-cleaning + summarization
Multi-perspective linking
Memory editing and versioning
Recipe book mode
Pet memories
Music-trigger & nostalgia-trigger modes
Private categories
Export in multiple formats (PDF, HTML, JSON)
5 GB media storage (option to expand)

Why People Upgrade:

The moment they try to upload more than 5 photos
The moment they attempt their first Family Memory Night
The moment they want the AI to help them write a chapter

Tier 2: Family Vault Plan ($20–$30/mo)

Target: Households or multi-generational families.

Includes everything in Premium, plus:

Up to 6 linked accounts
Shared vault + individual private vaults
Joint timelines
Group Memory Nights
Tagging other family members
Multi-perspective story stitching
Family tree autosync (from memories, not ancestry data)
50 GB media storage (expandable)

Why This Works:

One family storyteller can onboard the entire family.
People join because someone tags them.
Network effect: memories multiply in value when shared.

Tier 3: Legacy & Estate Plan (“Forever Vault”) ($199–$499 one-time or $99/yr)

This is the Apple iCloud “family plan” equivalent for your entire life story.

Includes:

Permanent archival storage
“Open after death” options
Story inheritance configuration
Vault transfer to children or heirs
Legal estate documents & instructions
Professional formatting of story collections
Time capsule mode (letters to future generations)

People will absolutely pay for this.
This is the modern version of a safety deposit box.

15.3 Optional Add-Ons (High-Margin Upsells)

These add-ons create significant extra revenue.

1. AI-Generated Memoir (“Your life as a book”)

Users can request:

a compiled autobiography
a themed memoir (e.g., “My Career,” “Our Love Story,” “Raising My Kids”)
a printed coffee-table book
custom illustrations

Price range: $49–$299 depending on complexity.

2. AI-Generated Family Recipe Book

Automatically compiles:

recipes
associated stories
contributor photos

Price: $39–$99.

3. Audio Storybook Production

Turn memories into:

narrated audio chapters
a family “podcast”

Price: $59–$199.

4. Transcription Packages

Bulk conversion of:

old audio cassettes
VHS tapes
old handwritten letters
diaries

Price: $0.10–$0.25/minute or bundled.

5. Printing & Digital-to-Physical Services

Partnerships with:

Shutterfly
Blurb
Print-on-demand services

Revenue share: 10%–30%.

15.4 Viral & Built-In Upsell Mechanics

WhatHappened naturally encourages users to invite others.

Upsell Trigger #1: Being Tagged in a Memory

When someone tags a friend or family member:

“You’ve been tagged in a story! Add your version?”

The tagged person creates an account → enters free tier → quickly hits limits → upgrades.

Upsell Trigger #2: Family Memory Night

The free tier only allows:

5 participants
20 shared prompts
no saved audio recordings

Upgrading unlocks:

unlimited prompts
all voices saved
automatic multi-perspective story stitching

Upsell Trigger #3: Timeline Gaps

“Between 1995 and 1998, your timeline looks empty. Want to fill it in?”

User tries → hits free tier limit → upgrades.

Upsell Trigger #4: Media Storage Full

Photo/video storage is the single strongest monetization lever.

Upsell Trigger #5: Memoir Mode

User sees a preview of their life chapters but must upgrade to unlock full export.

15.5 Cross-Product Bundling (Idea Vault + WhatHappened)

This is where your ecosystem becomes unbeatable.

Bundle Concept:

Your Past (WhatHappened) + Your Future (Idea Vault)
For one subscription.

Bundle Features:

memory vault
idea/knowledge vault
daily memory prompts AND daily idea prompts
“Past informs Future” cross-references
unified timeline of life events + ideas created
AI-generated Life Strategy Map

Pricing:

$15/mo individual
$35/mo family

Bundle increases retention dramatically.

15.6 Long-Term Revenue Streams

Beyond individual users, WhatHappened unlocks institutional markets:

1. Hospice & Palliative Care Organizations

Patients record life stories
→ families receive legacy vaults.

2. Funeral Homes

Memory compilations for memorial services.

3. Therapists & Counselors

Storytelling as identity reconstruction.

4. Schools & Teachers

“Interview your grandparents” assignments.

5. Genealogy Enthusiasts

Personal stories enrich Ancestry data.

6. Estate Planners

Digital legacy documents + stories.

These can become enterprise partnerships.

15.7 Pricing Philosophy

This platform is not utility software.
It is emotional software, like:

23andMe
Ancestry
StoryWorth
Legacybox
Evernote (for some)
Day One Journal

People do not churn easily from an emotional product.

Pricing must:

feel affordable
match emotional value
scale with usage
support long-term archival needs

Subscriptions create sustainability.
Legacy vaults create permanence.

15.8 Retention Loops Built Into the Product

Users remain subscribed because:

memories grow every month
nostalgia is addictive
family tagging creates network effects
AI retrieval improves with more data
memoir generation becomes better the longer you’re subscribed
it becomes part of daily reflection (“digitize your life”)
timeline becomes a habit
family history becomes a shared project

This is a product people stay with for years — even decades.

16. Growth Loop Architecture & Viral Expansion Strategy

Designing the engine that allows WhatHappened to spread through families, friend groups, and generations — without traditional advertising.

WhatHappened is inherently social, even though memories are private.
Every piece of the product can be architected to create natural invitations, emotional sharing, and cross-generational participation.

This section identifies the core viral loops, habit loops, identity loops, and network loops that will power platform growth.

16.1 The Three Pillars of Growth

Growth occurs because WhatHappened:

Invites family participation (network effect)
Generates emotionally compelling content (share effect)
Becomes part of someone’s self-understanding (identity effect)

These create a self-sustaining growth engine.

16.2 Viral Loop #1: The Tagging Loop (Most Powerful)

This is your equivalent of Facebook’s “tag a friend.”

Flow:

Eric adds a memory.
He tags Vicki.
The system asks:
“Notify Vicki? She may remember this differently.”
Vicki receives a message:
“Eric added a memory involving you. Add your version?”
She clicks → creates free account → adds her perspective.
She tags someone else in her version (e.g., Mom).
Mom joins → tags someone else.

This loop continues outward.

Why this loop is incredibly strong:

Tagging is emotionally meaningful, not transactional.
People are curious when someone says:
“This event involved you — do you remember it?”
People feel compelled to share their version.
The platform becomes a digital campfire.

16.3 Viral Loop #2: Memory Nights (Social Event Loop)

Memory Nights are a shared experience, similar to a game night or karaoke.

Loop Mechanics:

A user starts a Memory Night.
They invite others via link or text.
Participants take turns answering prompts.
Audio is recorded.
Memories are stored.
The recap (“Here are the stories you created…”) is shared with attendees.
Each attendee now has:
- a profile
- incomplete memories
- tags
- suggestions
They return later to fill in details.

Viral Effect:

Memory Night guests inevitably become platform users.

16.4 Viral Loop #3: Generational Pull-Forward (“Help me record Grandma’s stories”)

This loop starts with a younger person wanting to preserve an older relative’s memories.

Flow:

A grandchild wants to capture Grandma’s stories.
They use WhatHappened prompts in an interview.
Grandma’s stories are uploaded.
Other family members want access.
They create accounts.
They add their own stories.
The family vault grows.

Why this is powerful:

Every family has at least one “Historian of the Family.”
This tool gives them superpowers.
Family members often say,
“I want to add my memories too — let me sign up.”

This is inevitable viral growth.

16.5 Viral Loop #4: Emotional Exports (Shareable Outputs)

While most experiences remain private, the completed products are highly shareable.

Shareable outputs include:

Memory compilations
Storybooks
Recipe books
Audio story montages
Slideshows
“On This Date” memory highlights
Timeline views
Graduation/anniversary/life celebration collections

People naturally share these at:

weddings
funerals
birthdays
reunions
holidays

Every share introduces new users through a deeply emotional artifact.

16.6 Viral Loop #5: Nostalgia-Trigger Prompts (The “Oh my God, I remember that!” Loop)

Prompts like:

“What was your favorite class in 8th grade?”
“Did you ever have a childhood pet?”
“Where were you during Y2K?”

These create:

emotional resonance
immediate recall
a desire to respond
a desire to share with others:
“Do you remember when THIS happened?”

This triggers tagging → which restarts Loop #1.

16.7 Viral Loop #6: The Family Tree Overlay

When a user begins building a timeline for someone else (Mom, Grandpa), the system asks:

“Would you like to invite them to confirm or add details?”

Users often say yes.

Now that person is pulled into the network.

This is a multi-generational growth engine, like Medicare family plans.

16.8 Habit Loop: Daily Triggers That Keep Users Engaged

Daily Memory Prompt → New Memory → Timeline Growth → Celebration → Another Prompt

The system should celebrate every addition:

“One more piece of your story saved.”
“Your timeline for the 90s is looking richer.”
“You just unlocked the ‘First Job’ milestone.”

These micro-rewards form a dopamine loop.

16.9 Identity Loop: A Product People Talk About

People will identify as:

“I’m documenting my life.”
“I’m writing my family’s history.”
“I’m saving my grandparents’ stories.”
“I’m building our memory vault.”

Identity products spread because users talk about them.

This is how:

Peloton
23andMe
Notion
Day One
Duolingo

spread naturally.

WhatHappened fits this pattern.

16.10 Lifecycle Growth: The Life Events Expansion Path

People join during different life stages:

College: nostalgia + developing identity
Marriage: joint timeline
Having kids: documenting milestones
Middle age: preserving stories of parents
Retirement: reflecting on life
End of life: creating a legacy vault

Each life stage invites new users automatically.

16.11 Referral Incentives & Reward Systems

Optional incentives:

1. Free month for every successful invite

Invite 12 people → get a year free.

2. Unlock special features

“Invite 3 family members to unlock unlimited placeholders.”

3. Family tree bonuses

“Fill in a branch → earn a new set of prompts.”

Referrals work best when tied to meaning, not discounts.

16.12 Organic Social Growth Channels

We never share a user’s memories publicly.
But we can encourage users to share meta-content:

“I’m preserving my family history.”
“Just had our first Memory Night!”
“This app helped me record my grandma’s stories.”

These are powerful top-of-funnel messages.

The brand itself becomes:

“The place where your family’s stories live forever.”

16.13 Amplifier Loop: Fun + Meaning Creates Expansion

Products that are fun spread.
Products that are meaningful spread.
Products that are fun AND meaningful spread exponentially.

WhatHappened hits both:

Fun = prompts, games, Memory Nights, trivia
Meaning = preserving your life story and your family’s legacy

Few products have both.
This is your competitive moat.

16.14 Summary of the Growth System

Here is the growth system in one sentence:

Tagging pulls new people in → Memory Nights deepen relationships → Multi-perspective storytelling keeps people engaged → Timelines and exports create shareable artifacts → Life-events and nostalgia prompts bring users back repeatedly → The family expands outward one member at a time.

It is a self-reinforcing loop.

This is how WhatHappened becomes a generational product.
Once a family starts using it, they never stop.

17. MVP Roadmap & Phased Implementation Plan (0 → 12 months)

A practical, achievable, phased buildout from idea → prototype → beta → public launch → scale.

The WhatHappened platform is large, but the MVP does NOT need to include everything.
The key is to start with:

A personal memory vault
Basic RAG retrieval
Simple capture tools
Timelines
A limited family-sharing model

This is enough to create a product users love and will start paying for.

17.1 Product Development Phases Overview

Phase 0 – Pre-Build Foundation (Weeks 0–4)

Finalize data model
Determine initial tech stack
Build UX wireframes (low-fidelity)
Write prompt flows and story capture templates
Establish branding and design system
Acquire domain, hosting, and basic web presence
Define MVP feature set
Set up project repo, environments, CI/CD
Choose AI models (OpenAI, Anthropic, etc.)

Deliverable: Complete technical + design blueprint.

Phase 1 – MVP v1.0: Personal Vault Core (Months 1–3)

This phase creates the private memory vault for a single user, including:

Core Features

User signup/login (email, password, optional biometric)
Basic home dashboard
Add memory (text only at first)
Placeholder creation
Simple categories (Homes, School, Pets, etc.)
Timeline visualization (minimal version)
Single-person RAG retrieval
Edit memory (simple editor)
Export (basic PDF)

Data Infrastructure

PostgreSQL or Supabase
Storage for text and metadata
Embedding store (pgvector or Pinecone starter tier)

AI Infrastructure

Transcription API (optional in this phase)
Basic retrieval chain
Simple summarization/cleaning

Cost: Very low during this phase.

Goal:
Let one person store and recall >100 memories comfortably.

Success criteria:

Functional private memory vault
5–10 test users
They can add memories, edit them, and retrieve them accurately
Bugs tolerated, but flow must be emotionally compelling

Phase 2 – MVP v1.5: Media Support + Voice Capture (Months 3–5)

Added Features

Upload photos
Upload audio
Automatic transcription (OpenAI Whisper or similar)
Tagging of people
Improved category management
Improved timeline (with zoom and filters)
Rich memory viewer (with attachments)
Story-preserved versions + cleaned versions
Basic perspective linking (manual, not automatic)

AI Enhancements

Memory structuring suggestions
Tagging suggestions
Category refinement
Improved retrieval relevance

UX Improvements

Prettier dashboard
More intuitive capture UI
“Show memories for this decade”

Goal:
A person can now speak memories instead of typing — a massive unlock.

Success criteria:

Users begin adding more memories than before
Media appears in timeline
Retrieval across text + transcription works well

Phase 3 – MVP v2.0: Family Features + Multi-Perspective Mode (Months 5–7)

This is when the product shifts from personal → social and starts spreading naturally.

Added Features

Invite a family member
Shared vault
Tag a person & notify them
Family timeline (simple combined view)
Multi-perspective memory linking
Version comparison panel
Limited access control (Private vs Family)

Interaction Templates

Prompt sequence for “Capture someone else’s stories”
Cooperative memory creation (e.g., interviewing mom)

This enables the viral loops in Section 16.

Phase 4 – MVP Beta Launch (Months 7–9)

Public beta with limited waitlist.

Added Features

Memory Night Mode (basic version)
Nostalgia-prompts
Public timeline (global events)
Timeline auto-linking (e.g., “Song of the year”)
Initial pricing tier rollout
Stripe integration
“Upgrade to continue” modal when limits reached

Operational Systems

Analytics (Mixpanel or Amplitude)
Error monitoring (Sentry)
Customer feedback loops
In-app walkthrough/tutorial

Goal:
Real families begin using the platform together.

Success criteria:

500–2,000 beta users
NPS > 40
20% conversion to paid
Viral spread via tagging

Phase 5 – v2.5: Enhanced Family Systems + Multi-Media AI (Months 9–12)

Added Features

Story stitching (AI compiles multi-perspective story)
Recipe mode
Pet memory mode
Category-specific prompts
Event clustering (e.g., “All summer vacations”)
Optional couple-shared vault (romantic story mode)
Commenting/annotations
Advanced access controls
Media-to-text extraction (OCR for documents, EXIF location auto-linking)

This phase adds delight and depth.

Phase 6 – v3.0: Legacy Vault & Long-Term Features (Months 12–18)

Added Features

Legacy vault
Inheritance settings
“Open after death” memories
Time capsule mode
Memoir mode (export full chapters)
Printed storybooks
Advanced photo/video montage creator
Transcription packages
Family branches → complete biographies

Now the platform becomes generational.

17.2 Prioritization Framework

We prioritize features using these rules:

Rule 1: Anything that helps users capture memories is high priority.

Why? Without capture, nothing else matters.

Rule 2: Anything that helps users recall memories is medium priority.

Retrieval is important, but capture must come first.

Rule 3: Anything that helps families connect is a growth amplifier.

Tagging → invites → virality.

Rule 4: AI bells and whistles come after capture and family flows.

17.3 Development Team Requirements

A realistic early team could be:

Phase 1–3 Team

1 Lead Full-Stack Engineer (React Native + Node or Python)
1 Backend/AI Engineer
1 UI/UX Designer
1 PM (optional — could be you with AI assistance)

Phase 4+ Team

Add:

1–2 more full-stack engineers
1 mobile specialist
1 QA engineer
1 data/ML engineer

This keeps costs low until scale demands expansion.

17.4 Tech Stack Recommendation

Frontend

React Native (shared code iOS + Android)
Expo for rapid prototyping
Next.js for marketing site + web vault

Backend

Supabase or Firebase for MVP
Postgres for relational data
pgvector for embeddings
Python FastAPI or Node.js backend

AI

OpenAI Whisper for transcription
GPT-4.1 / 4.2 or Claude for text processing
Azure OpenAI for scalable enterprise hosting later
Pinecone or Weaviate if vectors outgrow pgvector

Media Storage

Supabase Storage (cheap)
Backblaze B2 or AWS S3 for scaling

17.5 Cost Estimates (Practical)

MVP (first 6 months)

$5k–$20k depending on developer structure
Hosting: $25/mo
AI usage: $50–$150/mo

Early Scale

$200–$800/mo (media + vector growth)

Large Families (1000+ users)

$2k–$6k/mo depending on media uploads

This business is profitable early because memory storage is cheap compared to emotional value.

17.6 Launch Strategy & Timeline

Soft Launch

Your family
Close friends
10–20 invited testers

Beta Launch (Phase 4)

Waitlist of 300–2,000
Family-focused onboarding
Weekly Memory Night events

Public Launch

After v2.5 or v3.0 is stable.

Target:

Mother’s Day
Father’s Day
Thanksgiving
Christmas

These are high-memory holidays → best viral spread.

17.7 KPIs & Success Metrics

Early MVP

Memories added per user
Session length
% of users who return within 48 hours
Number of placeholders created

Beta

Invite rate
Tag rate
Perspectives added
Timeline gaps filled
Monthly active families

Post-launch

Conversion to paid
Churn
ARPU (average revenue per user)
LTV (lifetime value)
Viral coefficient (K-factor)

17.8 Long-Term Vision (Beyond 18 Months)

AI-driven biography generation
Printed storybooks as a major revenue line
True multi-generational vaults
Life map visualization (decades, themes, core memories)
Family audio podcasts
Enhanced genealogy features
Integration with Idea Vault for “Past → Future” life mapping
AR/VR “memory museum” rooms

WhatHappened becomes the world’s family storytelling platform, a new category similar to:

Ancestry
Day One
StoryWorth
Google Photos
Notion

…but unified under a single purpose:
preserve, connect, and relive your life and family story.

18. Technical Architecture Blueprint

APIs, services, data flow, RAG pipeline, and scaling strategy for WhatHappened.

The WhatHappened platform is built as a modular, service-oriented system with:

a thin, friendly UI
a well-defined API layer
a set of focused backend services
a RAG pipeline that respects vault boundaries
a storage layer optimized for text, graph relationships, and media
observability and security baked in.

This section describes:

System overview & core components
API gateway & authentication
Microservices and their responsibilities
Key data flows (capture, edit, tag, retrieve, share)
RAG pipeline flow
Scaling strategy
Observability & reliability
Migration plan (MVP → scale)

18.1 High-Level System Overview

Core pieces:

Client Apps
- Web app (Next.js)
- Mobile app (React Native / Expo)
API Gateway
- Single entry point for all client requests
- Handles auth, rate limiting, routing
Microservices
- Auth & Accounts Service
- Vault Service (memories, placeholders, versions)
- People & Relationships Service
- Media Service
- Timeline Service
- Prompt & Gamification Service
- RAG Service
- Billing & Subscription Service
- Notification Service
Data Stores
- Primary relational DB (Postgres / Supabase)
- Vector DB (pgvector / Pinecone)
- Object Storage (S3 / Supabase Storage / B2)
- Caching (Redis)
- Analytics/event store (BigQuery / ClickHouse / similar later)
AI Integrations
- LLM provider (OpenAI / Anthropic / etc.)
- Whisper or equivalent for transcription
Observability
- Logging, metrics, tracing, alarms

Everything is wrapped in a multi-tenant architecture with family vault isolation.

18.2 API Gateway & Authentication

API Gateway Responsibilities

Terminate TLS
Validate JWTs / access tokens
Resolve user and vault context
Apply rate limiting (per-user & per-IP)
Route to appropriate microservice
Enforce simple authorization checks (coarse-grained)

Auth Stack

OAuth2 / OpenID Connect
Email/password + MFA
Access tokens (short-lived JWTs)
Refresh tokens (kept secure, rotated)
Optional social login (Google, Apple) later

Auth Flows

Sign Up
- POST /auth/signup
- Creates user record
- Creates default personal vault
Login
- POST /auth/login
- Issues JWT + refresh token
Invite
- POST /auth/invite
- Sends email with invite token associated with a vault and role (family member, guest, etc.)

18.3 Core Microservices & Responsibilities

1. Auth & Accounts Service

Handles:

user records
vault membership
roles & permissions
session management

Key endpoints (examples):

POST /auth/signup
POST /auth/login
POST /auth/refresh
GET /me
GET /vaults
POST /vaults/{vaultId}/invite

2. Vault Service (Memories, Placeholders, Versions)

This is the heart of the system.

Responsibilities:

CRUD for memories
CRUD for placeholders
Managing memory versions
Linking memories (related, perspectives)
Visibility settings

Example endpoints:

POST /vaults/{vaultId}/memories
GET /vaults/{vaultId}/memories/{memoryId}
PATCH /vaults/{vaultId}/memories/{memoryId}
DELETE /vaults/{vaultId}/memories/{memoryId}
POST /vaults/{vaultId}/placeholders
PATCH /vaults/{vaultId}/placeholders/{placeholderId}/convert
POST /vaults/{vaultId}/memories/{memoryId}/versions
GET /vaults/{vaultId}/memories/{memoryId}/versions

3. People & Relationships Service

Responsibilities:

Person records (user + non-user relatives)
Relationship graph (parent/child, spouse, sibling, friend)
Per-person timelines
Cross-person overlaps (for People Map)

Endpoints:

POST /vaults/{vaultId}/people
GET /vaults/{vaultId}/people/{personId}
PATCH /vaults/{vaultId}/people/{personId}
POST /vaults/{vaultId}/people/{personId}/relationships
GET /vaults/{vaultId}/people/{personId}/timeline

4. Media Service

Responsibilities:

Pre-signed upload URLs for photos/audio/video/docs
Thumbnails & transcoding
Linking media to memories
EXIF extraction & metadata enrichment

Endpoints:

POST /vaults/{vaultId}/media/upload-url
POST /vaults/{vaultId}/media
GET /vaults/{vaultId}/media/{mediaId}
GET /vaults/{vaultId}/media/{mediaId}/thumbnail

Behind the scenes:

Uses S3/Storage bucket
Lambda/worker for thumbnails and transcoding

5. Timeline Service

Responsibilities:

Construct personal & family timelines
Combine memories, people events, and world events
Provide filtered views (by year, decade, category, emotion)

Endpoints:

GET /vaults/{vaultId}/timeline?personId=&from=&to=&filter=
GET /public/timeline?year=1985

Integrations:

Reads from Vault, People, and World Events tables
Returns normalized “timeline event” objects for front-end visualization

6. Prompt & Gamification Service

Responsibilities:

Daily prompts
Memory Night prompts
Thematic question packs (childhood, school, romance, travel, etc.)
Tracking which prompts were used, which generated responses

Endpoints:

GET /vaults/{vaultId}/prompts/daily
GET /vaults/{vaultId}/prompts/memory-night
POST /vaults/{vaultId}/prompts/{promptId}/complete

Uses:

A simple prompt library table
Some LLM-assisted suggestion generation

7. RAG Service

Responsibilities:

Manage embeddings
Handle search & retrieval within a vault namespace
Orchestrate LLM calls for:
- answering questions
- stitching stories
- summarizing memories

Endpoints:

POST /vaults/{vaultId}/rag/query
POST /vaults/{vaultId}/rag/summarize-memory
POST /vaults/{vaultId}/rag/story-stitch

Internals:

Reads from Vault DB
Uses embedding pipeline (background workers)
Queries vector DB (pgvector / Pinecone) scoped to vaultId and visibility rules
Calls LLM with retrieved context

8. Billing & Subscription Service

Responsibilities:

Plan definitions (Free, Personal, Family, Legacy)
Stripe integration (or similar)
Subscription state & entitlement checks
Usage tracking (storage, API calls, etc.)

Endpoints:

GET /me/subscription
POST /billing/checkout-session
POST /billing/webhook (for Stripe events)

9. Notification Service

Responsibilities:

Email + push notifications (tagged in a memory, invites, prompts)
Preference management
Digest emails

Endpoints:

POST /notifications/send
GET /me/notifications/settings
PATCH /me/notifications/settings

18.4 Key Data Flows

18.4.1 Flow A: Capturing a New Voice Memory

User opens Capture screen in app.
Presses Record → audio captured locally.
Client requests upload URL:
- POST /vaults/{vaultId}/media/upload-url
Client uploads raw audio to storage using pre-signed URL.
Client posts memory stub:
- POST /vaults/{vaultId}/memories with:
  - memory_type = "audio-first"
  - media_id = uploaded file id
  - minimal metadata (title/rough date if known)
Vault Service creates Memory record.
Background Transcription Worker:
- Listens to a queue (e.g., audio_uploaded)
- Calls transcription API (Whisper)
- Saves transcript as MemoryVersion (type transcript)
- Optionally calls LLM to generate a cleaned version (type cleaned)
- Triggers embedding pipeline

Result: Within seconds to a minute, the voice memory is searchable and readable.

18.4.2 Flow B: Converting a Placeholder into a Full Memory

User sees placeholders list.
Clicks one: “Blue bicycle in Lexington.”
Presses Record or begins typing.
Client calls:
- PATCH /vaults/{vaultId}/placeholders/{placeholderId}/convert
- Payload includes raw_text (or attached audio → same pipeline as above)
Vault Service:
- Creates new Memory linked to this placeholder.
- Marks placeholder as converted and stores pointer to memory_id.
Transcription/embedding pipeline runs as usual.

18.4.3 Flow C: Tagging Someone in a Memory & Inviting Them

User edits a memory and tags “Vicki” (personId X).
If Vicki already exists as a Person and is linked to a user account:
- Notification Service sends:
  “Eric tagged you in a memory. Do you remember this?”
If Vicki is a Person with email but no account:
- System sends an invite link associated with that vault and that memory.
When Vicki clicks:
- She goes through signup.
- Auth Service links her user account to the personId.
- Vault membership is updated (role: family contributor or guest).
She can now:
- view the memory (respecting visibility rules)
- add her perspective:
  - POST /vaults/{vaultId}/memories with:
    - linked_to_event or perspective_group_id

18.4.4 Flow D: AI Retrieval — “Show me a story about my grandpa’s workshop”

User opens chat or search bar.
Sends query: “Tell me a story about Grandpa’s workshop.”
Client calls:
- POST /vaults/{vaultId}/rag/query with:
  - query_text
  - optional person filter (grandpa personId)
  - optional time filter (1960–1980)
RAG Service:
- Converts query to embedding.
- Queries vector DB, scoped to:
  - vaultId
  - visibility in {private if requester owns, family if user is family, etc.}
- Retrieves top N memory chunks and metadata.
- Calls LLM with:
  - retrieved context
  - instructions: “Preserve storyteller’s voice where possible / or generate neutral summary if requested.”
Response formatted as:
- summarized story
- optional links to original memories
- suggestions: “Want to add more stories about this?”

18.4.5 Flow E: Family Timeline View

User opens Family Timeline screen.
Client calls:
- GET /vaults/{vaultId}/timeline?mode=family&from=1970&to=2020
Timeline Service:
- Fetches all memories in vault between those dates, where:
  - visibility includes requester
- Fetches family events (births, moves)
- Optionally overlays world events from global timeline DB
Returns:
- list of timeline events grouped by year
- counts per category
- flags for “gaps” (few or no events)

18.5 RAG Pipeline Architecture

The RAG pipeline is central to the product. It operates with family-vault isolation as the primary invariant.

18.5.1 Ingestion Pipeline (When Memories Are Created/Updated)

Vault Service emits an event:
- memory_created or memory_updated.
An Ingestion Worker:
- Reads the latest “canonical” factual text (cleaned/edited).
- Optionally also processes a story-preserved version for storytelling tasks.
Chunking:
- Splits content into atomic segments (1 idea, 1–3 sentences).
- Attaches metadata:
  - vaultId
  - memoryId
  - personIds
  - date_range
  - categories
  - visibility
Embedding:
- Calls embedding model.
- Stores vectors in Vector DB namespace keyed by vaultId (and optionally sub-namespaces per person or per “visibility level”).

Result: Everything is ready for semantic search.

18.5.2 Retrieval Pipeline (At Query Time)

RAG Service receives a query with context:
- userId
- vaultId
- optional filters (person, time, category)
Permission filter:
- Determine which memories this user may see.
- Use that as a filter on vector search (“visibility <= user role”).
Vector search:
- Retrieve top N chunks.
Ranking & grouping:
- Group by memory, person, theme.
- Possibly down-rank conflicting or low-confidence entries.
LLM call:
- Insert instructions like:
  - “If there are multiple perspectives, mention them.”
  - “Preserve key details and unique language.”
  - “Offer links or references to the original memory IDs if user wants to read the full story.”
Return structured result:
- direct answer or stitched story
- snippets & memory references
- related prompts (“Ask about X next?”)

18.6 Scaling Strategy

Early Stage (MVP, 10–1,000 users)

Single Postgres instance (Supabase)
pgvector for embeddings
Single storage bucket
Simple serverless functions / small container cluster
Minimal caching

Growth Stage (1,000–100,000 users)

Dedicated Postgres with read replicas
Separate vector DB (Pinecone/Weaviate)
Cache hot queries in Redis
Shard by vault or region if needed
Use CDN for media delivery
Scale microservices horizontally behind a load balancer

Mature Stage (100,000+ users)

Multi-region DB deployment
More advanced sharding strategy
Separate compute clusters for:
- ingestion & indexing
- RAG queries
- media processing
Rate limits & usage quotas by plan

18.7 Observability & Reliability

Metrics to track:

Requests per service
Latency per endpoint
Error rates
Memory ingest lag (time from capture to RAG-available)
RAG query latency
Media processing queue size
Storage usage per vault
LLM usage and cost

Tools:

Centralized logging (e.g., ELK, Loki)
Metrics & dashboards (Prometheus + Grafana, Datadog)
Tracing (OpenTelemetry)
Alerting on:
- high error rate
- elevated latency
- failing ingestion
- low transcription success

Reliability goals:

99.9% uptime for core APIs
Transcription & indexing can be slightly eventual (seconds–minutes delay)

18.8 Migration Plan (MVP → Production-Grade)

Start simple:
- Supabase backend
- pgvector for embeddings
- Single React/React Native codebase
Abstract the RAG Service early:
- Even if initially it just calls OpenAI directly, wrap it behind your own API.
Introduce Vector DB later:
- Once pgvector performance becomes a concern, switch to an external vector DB under the same RAG API.
Gradually extract microservices:
- Begin as a monolith (or “modular monolith”) with clear boundaries.
- Extract Vault, People, RAG, Media as separate services when necessary.
Move from single-region to multi-region infrastructure:
- DB read replicas first
- Then full multi-region for failover and locality

18.9 Summary

The technical blueprint for WhatHappened is:

Modular and future-proof (services & clear data model)
Emotionally focused (fast capture, low friction)
Security-conscious (vault isolation, permission filters in RAG)
Scalable (start small, grow via sharding and vector DBs)
AI-native by design (RAG as a first-class component, not an afterthought)

Taken together, Sections 11–18 give you:

the conceptual layers,
the data model,
the UX patterns,
the privacy model, and
now the concrete services & flows
to actually build WhatHappened.

19. Brand, Naming, & Positioning Framework

Defining how WhatHappened presents itself to the world — its identity, language, tone, emotional hooks, and strategic differentiation.

This section covers:

Brand Purpose & Promise
Core Value Proposition
Naming Framework
The “Three Personas of the Brand”
Taglines & Short Descriptions
Competitive Positioning
Differentiators
Emotional Hooks
Voice & Tone Guidelines
Messaging Architecture
Product Tiers & How to Position Them
Pre-Launch & Post-Launch Narrative
Brand Risks & Guardrails

19.1 Brand Purpose & Promise

Purpose (Why we exist)

To help people preserve the most meaningful parts of their lives — their stories, relationships, and personal history — in a way that feels effortless, enjoyable, and enduring.

Promise (What users can rely on us for)

We promise to gently capture and preserve the moments, stories, and memories that matter… even the ones people didn’t realize they’d forgotten.

WhatHappened is the safest, smartest, and most human way to remember a life.

19.2 Core Value Proposition

Simple version (external messaging)

Capture your life, one memory at a time — automatically organized, emotionally intelligent, and instantly retrievable.

Expanded version (strategic)

WhatHappened helps you:

easily record memories — through voice, text, photos, video, or uploaded documents
organize them automatically by date, people, place, and theme
build timelines for yourself and your loved ones
surface forgotten stories through gentle AI-powered prompts
share and connect through family storytelling
preserve multiple perspectives around the same event
offload mental clutter and free your mind

It’s the first memory vault designed for both looking back and living forward.

19.3 Naming Framework

Product Name: WhatHappened

Rationale:

Conversational and human
Immediately implies storytelling and memory
Works as both a question (“What happened?”) and a statement (“Here’s what happened.”)
Invites curiosity and narrative
Easy to spell, easy to say, emotionally sticky

Alternative “umbrella” names (future optional):

WhatHappened Vault
WhatHappened Memory Vault
WhatHappened Stories
WhatHappened Family Vault
WhatHappened AI

You may choose to use:

WhatHappened for the consumer-facing product
Memory Vault as the product module inside it
Idea Vault as the entrepreneurial parallel brand (already planned)

19.4 The Three Personas of the Brand

The brand speaks with three interwoven identities:

1. The Archivist

Calm, organized, trustworthy.
It ensures nothing is lost.
Keywords: preserve, safe, enduring, documented, organized.

2. The Storyteller

Warm, nostalgic, emotional.
It helps users turn memories into shareable narratives.
Keywords: remember, relive, connect, share, family, meaning.

3. The Assistant

Helpful, modern, AI-enabled.
It prompts, suggests, categorizes, and retrieves.
Keywords: effortless, smart, intuitive, guided, personal.

All three must appear in the brand voice — stability + warmth + intelligence.

19.5 Taglines & Short Descriptions

5–10 Word Taglines

Your life. Remembered.
Never lose a story again.
Capture today. Cherish forever.
The simplest way to remember your life.
Your memories, organized and alive.

Longer Taglines

Preserve the stories that shape your family.
A gentle way to remember what matters most.
The memory vault powered by human storytelling and smart AI.

App Store description (short)

WhatHappened helps you easily capture, organize, and relive your life stories. Record memories with your voice, upload photos, tag family, build timelines, and discover forgotten moments through gentle AI prompts.

19.6 Competitive Positioning

WhatHappened sits at the intersection of:

Journaling apps (Day One, Reflectly)
Genealogy platforms (Ancestry, MyHeritage)
Scrapbook/photo apps (Google Photos, Forever, Chatbooks)
Consumer AI assistants (ChatGPT, Rewind, etc.)

We are not just one of these.

We are the only platform that:

blends all four into a unified memory-knowledge system
organizes memories automatically using AI
supports multiple perspectives on the same story
allows for family collaboration and tagging
preserves stories in both raw and refined versions
connects memories to world events
gamifies memory capture
builds timelines for people who are not even users (parents, grandparents)

This is a category-creating product.

19.7 Key Differentiators

1. Multi-perspective storytelling

Most memory apps assume one storyteller.
WhatHappened captures a story from everyone who lived it.

2. Memory prompts that spark more memories

Our prompt engine is emotionally intelligent and adaptive.

3. The Placeholder System

Capture ideas fast — fill in later.
This radically lowers friction.

4. Family Tagging & Invitations

Tag someone in a story → they’re invited to confirm or add their version.

5. The Global Timeline Integration

No other product aligns your life with world events to spark recall.

6. Fiction + non-fiction versions of each memory

For storytelling, books, family letters, memorials — hugely valuable.

7. A RAG system designed for memories

Search your life like it’s a personal encyclopedia.

8. Legacy Mode

Preserve a life even if the person is no longer alive — through interviews, documents, transcripts, and family stories.

You’re not building an app.
You are building the first AI-powered personal history engine.

19.8 Emotional Hooks

These are the feelings that drive adoption and retention:

“I don’t want to forget.”
“I want my kids to know who we were.”
“I wish I had more stories from my grandparents.”
“We never write anything down — but now we can.”
“I want to save this before I lose it.”
“Our family history feels scattered — this brings it together.”
“I love hearing my parents’ voices telling their stories.”
“Seeing our timeline helps me understand my life differently.”

These are powerful motivators — your marketing will tap into them again and again.

19.9 Brand Voice & Tone Guidelines

Voice Characteristics

Warm
Trustworthy
Curious
Calm
Gentle
Organized
Non-judgmental
Helpful

Tone by Situation

Story prompts: encouraging, curious
Editing tools: clean, concise
Family invites: warm, respectful
Notifications: light, friendly, never needy
AI-generated summaries: neutral, clear
Marketing: emotional but grounded
Privacy & security copy: firm, confident, serious

Things we never do:

Guilt users
Overwhelm with options
Use technical jargon
Make AI the hero
Act like a “therapy session”

The brand’s job is to feel like a safe place for your life story.

19.10 Messaging Architecture

High-level messaging

Capture everything worth remembering.
See your life in context.
Build a legacy for your family.

Mid-level messaging

Record your stories with your voice
Organize memories effortlessly
Tag the people who were there
Reconstruct full stories from multiple perspectives
Discover forgotten moments
Build a timeline of your life
Create a family vault that grows over time

Feature-level messaging

Placeholder system
Audio transcription
Memory prompts
People tagging
Date estimation
World events overlay
Editing tools
RAG-powered search
Export (PDF, audio, stories)
Family permissions
Shared timelines

19.11 Product Tiers & Positioning

Free Tier (Lead Magnet)

Includes:

Create memories
Create placeholders
Basic timeline
Limited storage
1 person (yourself)
Access to global timeline
Limited RAG search
Basic prompts

Positioning:

“Try remembering again.”

This tier exists to:

capture emails
let people feel the magic
encourage upgrading when they want to add family or media

Personal Tier (Core Product)

Includes:

Unlimited memories
Unlimited placeholders
Full RAG
Voice recording & transcription
Personal timeline builder
Add unlimited non-user people (grandparents, etc.)
Export tools

Positioning:

“Build your life story.”

Family Tier (Flagship Product)

Includes everything in Personal plus:

Up to X family members
Shared vault
Memory tagging and multi-perspective threads
Family timeline
Family prompts
Memory Night mode
Shared albums
Collaborator permissions

Positioning:

“Build your family history together.”

This is the heart of your revenue model.

Legacy Tier (Premium)

For families capturing the life of:

aging parents
grandparents
people with dementia or memory decline
memorials
end-of-life storytelling
heritage preservation

Includes:

Interview mode
Story stitching
Biography generation
“Life Book” PDF export
Private hosting for future decades
Digital inheritance management

Positioning:

“Preserve a life. Share a legacy.”

This tier has enormous emotional and financial value.

19.12 Pre-Launch & Post-Launch Narrative

Pre-launch message

The story is about why this matters, not what the app does.

“Our memories fade. Our stories get lost.
But what if they didn’t?”

The pre-launch campaign focuses on:

emotional resonance
nostalgia
curiosity
early-access waiting list
“Founding families”
gathering initial memory prompts
influencer stories about forgotten memories

Post-launch message

Now the focus shifts to ease and utility.

“Remembering your life shouldn’t be difficult.”
“Now it only takes a moment.”

Marketing focuses on:

tutorials
demos
how fast it is
how magical the retrieval feels
example stories
the family value

19.13 Brand Risks & Guardrails

Potential Risks

Feeling too “techy” or clinical
Overemphasis on AI instead of human stories
Privacy concerns not addressed clearly
Overcomplicating onboarding
Making users feel guilty for not capturing more
Feeling like “another social media platform”

Guardrails

Always emphasize human first, AI second
Be explicit about data isolation and privacy
Provide storytelling guidance that invites, not pressures
Use gentle copy everywhere
Highlight the joy of remembering, not the fear of forgetting
Never require a user to “perform” for the app
Celebrate small wins (“You saved a memory today!”)

20. Go-To-Market Strategy & Launch Roadmap

Overview

This section defines how WhatHappened goes from concept → MVP → early adopters → mass-market consumer app.
It covers:

Target customer segments (early → mainstream)
“Founding Families” phase
Pre-launch marketing funnel
Product-led onboarding strategy
Viral loops & organic growth
Launch sequencing (MVP → Alpha → Beta → Full Launch)
Marketing channels & messaging for each stage
Growth KPIs
Expansion roadmap after launch

Everything here is designed to leverage:

your unique personal network,
your storytelling ability,
your content-creation engine (videos, posts, email lists),
the emotional weight of the product category, and
the viral nature of family-tagged memories.

20.1 TARGET CUSTOMER SEGMENTS

Phase 1 – Early Adopters (Emotionally Motivated Users)

Focus on people who are already thinking about family history, memory preservation, or aging parents. These groups adopt very quickly:

Adults with aging parents (40–70 age range)
Parents who want to capture their kids’ childhood
People who recently lost a loved one
Genealogy hobbyists
Storytellers, scrapbookers, memoir writers
Therapy/coaching clients working through personal history
Anyone who keeps journals or uses “Notes” constantly
Individuals with large photo libraries they want to organize

This audience “gets it” instantly.

Phase 2 – The Family Network Expansion

Once one person joins, others follow:

siblings
parents
adult children
cousins
close friends
spouses/partners

This is where viral loops kick in, because stories naturally include other people.

Phase 3 – Mainstream Consumer Market

Once features mature:

young adults (18–30) through gamification and storytelling
couples (date-night storytelling)
workplaces for team-retrospectives
schools (senior memory books)
retirement communities
grief groups

This is where the product becomes mass-market — easy, fun, viral.

20.2 THE FOUNDING FAMILIES PROGRAM (Invite-Only Pre-Launch)

This is your strategic advantage and early traction engine.

Purpose:

Test features on real humans
Collect thousands of real memories to train prompts
Refine UX
Capture testimonials and case studies
Seed the RAG with real-world memory patterns
Create emotionally powerful marketing stories

Structure:

Invite 20–40 early “Founding Families” (this can include your family and close contacts)
Give them free lifetime Personal Tier access
Give them 6–12 months of free Family Tier
Ask for:
- weekly feedback
- permission to anonymize sample stories
- permission to use their timelines and screenshots (with consent)
- participation in “Memory Nights” testing

Deliverables from Founding Families:

10,000+ early memories
Validation of the placeholder system
Real examples of story variations (multiple perspectives)
Real family dynamics and tagging patterns
Ironclad onboarding flows

This phase ensures the app is already emotionally sticky before it goes public.

20.3 PRE-LAUNCH MARKETING FUNNEL

The goal:

Build a waitlist of 10,000+ people before launch.

The engine:

A simple, powerful 3-step funnel:

Step 1 – Curiosity Entry Points (Top of Funnel)

Content that sparks emotion and nostalgia:

Short videos on “5 memories people wish they had saved”
Posts about aging parents and legacy
Before/after examples of memory reconstruction
“The story I wish I had asked my grandfather” series
Real Founding Family stories
Screenshots of timelines
Examples of placeholder prompts

These posts will explode on TikTok, Instagram, and YouTube Shorts.

Step 2 – The Lead Magnet (Middle of Funnel)

Offer a free tool that provides instant value:

“50 Memory Prompts Everyone Should Answer Before Age 50”
“Your Personal Timeline Starter Kit” (PDF, interactive)
“The Couples Date-Night Story Guide”
“10 Questions to Ask Your Parents Before It’s Too Late”

People LOVE this material.
They share it.
They save it.
They tag siblings.

Every download → adds to the WhatHappened waitlist.

Step 3 – Waitlist with Early Access Incentives (Bottom of Funnel)

Offer:

30 days of Family Tier for free
“Founder” badge inside the app
Priority invitations
Early access to Memory Night mode
Exclusive prompts

You can easily get 10,000–50,000 sign-ups with the right content strategy.

20.4 PRODUCT-LED ONBOARDING STRATEGY

When users join, the app must help them succeed fast.

The “First Magic Moment”

Within 60 seconds, the user should:

Add their first memory
See it categorized
See it placed on a timeline
Get a personalized prompt (e.g., “Do you want to add where you lived then?”)

This is the dopamine hit.

The “Second Magic Moment”

Within 5–10 minutes, the user:

Tags someone else in a memory
Realizes stories are richer in multiple voices

This triggers viral growth.

20.5 VIRAL LOOPS AND ORGANIC GROWTH

Your product has built-in network effects stronger than any journaling app.

Viral Loop 1: Tagging Someone in a Memory

Flow:

“Eric tagged you in a memory — do you remember what happened?”
Receiver clicks → creates an account (free tier)
They add their version of the story
They begin browsing the public timeline
They start adding memories

This loop alone can drive millions of users.

Viral Loop 2: Family Timeline Invitations

Families love seeing their lives woven together.

Viral Loop 3: Exportable Stories

Users can export memory bundles for:

memorials
birthdays
anniversaries
weddings
family reunions

These exports contain gentle branding → leading to organic referrals.

Viral Loop 4: Memory Night Mode

Families host memory nights and everyone downloads the app that evening.

This is powerful and unique.

20.6 LAUNCH SEQUENCING

Phase 0 – MVP (Internal & Founding Families Only)

Core features:

voice capture
transcription
placeholder creation
date tagging
people tagging
basic timeline
edit + save memory
global timeline (basic version)

Not required:

full RAG
world event overlays
Memory Night mode
AI summarization
advanced media browsing

The MVP’s job: capture raw memories.

Phase 1 – Private Alpha (100–200 Users)

Focus:

UX improvements
memory prompts
RAG retrieval testing
emotional resonance
fixing confusion points

Phase 2 – Private Beta (500–2000 Users)

Add:

family vault
multi-perspective threads
timeline visualization
world events overlay
search engine
media uploads
advanced prompts

This is where “Wow, this is magic” begins.

Phase 3 – Public Beta (10,000–50,000 Users)

Release to the waitlist.

Add:

Memory Night mode
Date-night storytelling
Export tools
Enhanced RAG retrieval
Privacy tiers
Legacy mode (in early form)

Phase 4 – Full Launch (Public)

Everything is polished.
You now market directly to the public.

The messaging changes from:

“Join the waitlist to get early access.”

to:

“Start capturing your life, today.”

20.7 MARKETING CHANNELS & STRATEGIES

This product DEMANDS emotional storytelling — and that’s exactly what the internet rewards.

20.8 EARLY GROWTH KPIs

For MVP:

10 memories per user per week
1–2 tagged people per user
80% who create at least one placeholder return within 72 hours

For Beta:

40% of users engage weekly
20% invite 1+ family member
1 exported story bundle per 50 memories saved

For Launch:

Paid conversion rate target: 3–5%
Viral coefficient target: 1.1–1.3
Churn rate < 3% monthly

20.9 EXPANSION ROADMAP (POST-LAUNCH)

After foundation releases:

Year 1:

AI biography generator
AI “Life Chapters” mode
Couples mode
Memory Night party kit
Multi-language support
Childhood reconstruction prompts

Year 2:

AI voice synthesis for memorials
Interactive photo timelines
School partnerships
“Life Book” hardcover print-on-demand
Integration with phone call recording (user-permitted)

Year 3:

Integration with VR/AR
Generational family timelines (six generations deep)
Enterprise partnerships for legacy programs

WhatHappened eventually evolves into the world’s leading personal legacy and memory preservation platform.

21. Pricing & Revenue Strategy

Overview

This section defines:

The core pricing tiers
Feature gating between those tiers
Behavioral psychology behind upgrade triggers
Revenue model (subscription, add-ons, family plans, legacy plans)
Freemium acquisition strategy
Viral monetization loops (how tagging → conversions)
Long-term revenue expansion paths
Market positioning versus competitors
Price testing & optimization

The pricing model is designed to maximize virality, ease of entry, stickiness, and lifetime value, while remaining emotionally sensitive to the nature of memories.

21.1 Pricing Philosophy

Pricing must reflect three truths:

1. Memory preservation is invaluable, but users hesitate to pay upfront.

So we use a freemium model where value is felt before payments begin.

2. Families are the real revenue engine.

One person starts, but upgrades become natural when stories involve:

parents
siblings
spouses
kids
grandparents

3. The emotional nature of the product demands gentle monetization.

No hard sell. No guilt tactics.
Pricing should feel:

respectful
empowering
optional
worth it

21.2 Core Pricing Tiers

Below is the recommended initial pricing model.
These numbers are based on competitive benchmarking (journaling apps, genealogy tools, consumer AI subscriptions, digital scrapbooking, and family vault apps).

Tier 0 — Free Plan

Price: $0 forever
Purpose: Viral growth + lead capture + emotional hook

Included:

Create unlimited text memories
Create unlimited placeholders
Add 1 person (yourself)
Attach up to 10 photos
Basic timeline view
Limited world-events timeline (e.g., major headlines only)
Light RAG search (e.g., 10 searches per month)
10 AI memory prompts per month
Export a single memory at a time (not bundles)

Restrictions (intentional upgrade triggers):

No voice recording/transcription
No capturing stories about non-users
Cannot add multiple perspectives
Cannot build timelines for parents/children
Cannot create a family vault
Cannot invite others
Cannot host Memory Night
Limited storage

Why this works:

The user feels the magic but quickly wants more.
Tagging someone causes an immediate upsell moment.
Placeholder backlog encourages upgrades.

Tier 1 — Personal Plan

Price: $8–$12/month or $80–$120/year
Target: Individuals capturing their own life

Included:

Everything in Free, plus:

Unlimited memories, placeholders, and text
Unlimited photos & documents
Voice recording + transcription
AI-enhanced summaries
Build timelines for unlimited non-user people
(e.g., parents, grandparents — huge emotional feature)
Multi-perspective memory threads
People tagging (non-users included)
Full world-events overlay
Full RAG search
Memory editing tools
Story reconstruction (AI-assisted)
Export story bundles (PDF, audio, biography chapters)

Why this tier succeeds:

Most users want to organize:

childhood stories
family history
parents’ stories
memorials
life events

But they don’t yet feel ready to involve their whole family.

Tier 2 — Family Plan (Flagship)

Price: $18–$25/month or $180–$240/year
Target: The REAL customer.

Included:

Everything in Personal, plus:

Up to 5–8 family accounts
Shared family vault
Family timeline
Memory Night mode
Multi-user story threads
Tagging triggers notifications to others
Real-time collaboration
Family-specific AI prompts
Shared albums and story collections
Family permission controls

Why this tier is the revenue driver:

Every tagged family member represents a conversion opportunity
Family vaults become a permanent, emotional digital asset
Extremely high retention (similar to ancestry/genealogy subscriptions)

Tier 3 — Legacy Plan (Premium)

Price: $35–$49/month or $350–$490/year
Target:
Families preserving the life of someone:

aging
with fading memory
with dementia
nearing end of life
recently deceased

Included:

Everything in Family, plus:

Interview Mode (guided sessions for capturing a life)
AI Biography Builder (book generation)
Voice-preservation exports
Audio timeline generation
Memorial export toolkit
Private long-term hosting (guaranteed X years)
Digital inheritance settings

This tier aligns with high emotional value → high willingness to pay.

21.3 Add-On Revenue Opportunities

Add-on A: Extra Users in Family Vault

Additional members: $3–5 per month each.
Great for large families.

Add-on B: Print-on-Demand Life Books

AI-designed hardcover books
High-margin revenue
Perfect for holidays, birthdays, memorials

Add-on C: Expanded Storage

Especially for families uploading thousands of photos/videos.

Add-on D: Event-Based “Story Bundles”

For:

weddings
anniversaries
graduations
funerals
family reunions

AI auto-generates a book or slideshow from the vault.

21.4 Psychological Upgrade Triggers (Built Into Product Flow)

Pricing should not rely on banners or nags — it should rely on behavior.

These upgrade triggers feel natural:

Trigger 1: Tag Someone in a Memory

Popup:

“To add their perspective, upgrade to Family Plan.”

Trigger 2: Trying to Voice Record

Popup:

“Voice memory capture is part of the Personal Plan.”

Trigger 3: Trying to Save a Story About Someone Else

Popup:

“Build timelines for parents, grandparents, and loved ones in the Personal Plan.”

Trigger 4: Limit Reached on Prompts/Search

Popup:

“Get unlimited prompts with the Personal Plan.”

Trigger 5: Creating a Story Bundle

Popup:

“Export multiple memories as a collection with Personal or Family Plan.”

These are gentle, non-pushy prompts that drive high conversions.

21.5 Viral Monetization Loops

WhatHappened has two of the strongest viral engines possible.

Loop A: Tagging → Invitations → Conversions

Flow:

Eric creates a memory
Tags his sister
She receives notification
She sees the memory
Adds her version
Gets emotionally hooked
Upgrades for her own vault

Loop B: Family Vault Invitations

People rarely say no to family.

Loop C: Export tools

Families export stories for events → others see them → want the app.

Loop D: Memory Night mode

Whole households sign up simultaneously.

21.6 Free vs. Paid Feature Gating Strategy

Free Tier shows:

the magic
the timeline
the prompts
the organization

But hides:

collaboration
transcription
world-event overlays
multi-perspective threading

This is textbook SaaS psychology:
Offer value → reveal more value → upgrade feels obvious.

21.7 Price Testing Strategy

Post-launch:

Test variables:

$8.99 vs. $11.99 for Personal
$18.99 vs. $24.99 for Family
Monthly-only options vs. yearly discounts
Family size caps (5 vs. 8)
Whether Legacy should be monthly or only annual

Testing channels:

onboarding flow
email sequences
pricing page variations
retargeting ads

Metrics to watch:

trial-to-paid conversion
churn rate
ARPU
attach rate of add-ons
usage-driven retention

21.8 Competitor Pricing Comparison

Journaling Apps (Day One, etc.)

$35–$60/year
No family collaboration
No world timeline

Genealogy (Ancestry)

$24–$50/month
No memory capture
No daily storytelling

AI Memory Tools (Rewind)

$20–$30/month
Not emotional, just functional

Scrapbooking/Photo Books

Expensive add-ons
No intelligent organization

WhatHappened delivers much more than each category for an equivalent price.

Your pricing is competitive and reasonable.

21.9 Long-Term Revenue Expansion

Once the core product matures, additional avenues open:

1. Corporate “Legacy-as-a-Benefit” program

Employers sponsor subscriptions for employees to capture family memories.

2. Senior living facilities

Offer the app as part of onboarding for residents.

3. Hospitals and hospice programs

Memory capture as part of grief support.

4. Schools

Yearbook replacement concept.

5. Therapist/coach add-on

Private vault + structured prompts.

6. Partnership with funeral homes

Offer legacy books as part of packages.

This product has massive vertical expansion potential.

22. UX / UI Screen Architecture & User Flow Design

Overview

This section defines:

The core UX philosophy
The primary screens of the app
The memory capture interface (voice, text, placeholder)
The timeline system (personal, family, world)
How users view, edit, and navigate memories
The tagging and multi-perspective interface
Family Vault UX
Memory Night UX
Onboarding flows
Upgrade flow (“soft monetization”)
Visual design system & UI components

This is the foundation for all product development.

22.1 Core UX Philosophy

The UX must feel like:

1. Gentle

Never overwhelming.
Small, simple steps.
Minimal text.
Warm colors, soft animations.

2. Fast

Memories are fleeting thoughts.
The interface must capture them in under 5 seconds.

3. Invisible Structure

The system organizes everything, but the user never sees complexity.

4. Timeline-Centric

The user always understands when things happened.

5. Emotionally Neutral

No guilt.
No red warning banners.
No “you missed a day!” notifications.

WhatHappened is a memory sanctuary, not a task manager.

22.2 Primary Screen Architecture (App Navigation Model)

The app will have five main tabs (bottom navigation):

TAB 1: Home (Prompts + Quick Capture)

Today’s memory prompt
Quick capture buttons
Placeholder creation
“Continue a memory you started earlier”
Suggested memories based on triggers, dates, seasons

TAB 2: Memories (List + Search + Filters)

Full memory list
Filter by tags, people, places, categories
Search powered by RAG
Smart folders (“Trips,” “Homes,” “School Years,” “Pets”)
Recently added
Recently edited

TAB 3: Timeline

Personal timeline
Global/world timeline overlay
Family timeline (Family Plan+)
Zoom levels (decades → years → months → days)
Dots or cards representing memories

TAB 4: Family

Family Vault home
Member list
Memory threads with multiple perspectives
Tagging dashboard
Shared albums
Memory Night mode

TAB 5: Profile / Settings

Subscription status
Export tools
Privacy & permissions
App settings
“People I’ve Added” list (parents, grandparents, etc.)
Backup & archive

This structure is extremely intuitive and mirrors the mental model of:

capture
browse
timeline
family
settings

22.3 Memory Capture Experience (The Heart of the App)

There are three ways to capture a memory:

Method 1: Voice Capture (Primary Method)

Voice Capture Screen Layout

Large microphone button in center
Pulsing ellipses during recording
“Tell your story…” gentle prompt
Optional: “Who was there?” / “When did it happen?”
Waveform animation
Stop → Transcribe → Preview

UX Flow

User taps microphone
Speaks freely
System automatically:
- generates a title suggestion
- estimates date
- detects people mentioned
- detects themes/tags
User confirms or edits
Memory saved
Optional: “Would you like to add a picture?”

This must feel magical, fast, pleasant.

Method 2: Text Capture

Layout:

Blank text box
Prompt at top (“What do you remember?”)
Quick tag chips below text box
Optional date picker
Optional photo attachment

This is the “journal-like” interface.

Method 3: Placeholder Capture

Placeholder UX:

This is a unique innovation — so the UX must be frictionless.

Screen layout:

Short text field (“Add a quick memory idea…”)
Checkbox: “Ask me to fill this in later”
Option: assign category
Option: assign person

Saved placeholders appear:

in a separate “Incomplete Memories” folder
as yellow cards
with an icon
with estimated tags (e.g., “Childhood,” “Grandpa”)

Placeholder prompts are part of onboarding and retention.

22.4 Memory Card UI (How Each Memory Looks)

Every memory appears as a Memory Card, with:

Title
Date (estimated or confirmed)
Photo (if present)
First 1–2 lines of text
Icons for:
- voice recording
- number of perspectives
- number of tagged people
- attachments

When tapped → opens Memory Detail View

22.5 Memory Detail View

This is the most important screen after capture.

Layout:

Top Section

Title
Date range (if uncertain)
People icons (faces or initials)
Place
Category chips

Body

Full text
Audio recording (if exists)
Attached photos/videos
Version history (for raw + refined)
Placeholder status (if incomplete)

Perspective Threads (Family Plan+)

If others add their version:

Appear as side-by-side thread summaries
Visual indicator: “2 perspectives available”
Tap to expand → “Eric’s version” / “Vicki’s version”

AI Tools (Personal+)

Summarize
Improve writing (optional)
Create storybook version
Extract timeline events

Actions

Edit
Tag more people
Export
Move to album
Audio-only playback

This design is minimal, warm, and readable.

22.6 Timeline UX (Your Life, Visually)

The timeline comes in three modes:

Mode 1: Personal Timeline

Objects shown:

memories
major life events (homes, schools, jobs, pets)
photo clusters
placeholder reminders

Zoom gestures:

pinch to zoom
scroll left/right

Memories appear as:

dots
cards
images
grouped clusters

Mode 2: Family Timeline (Family Plan)

Merged timeline showing:

overlapping events
shared memories
linked people

Filtering:

show only Eric
show only Vicki
show both
show grandparents
show only “Trips”

This becomes the visual representation of a family history.

Mode 3: Global Timeline Overlay

Slide-over panel shows:

world news
movies
music
fashion
technology
prices
sports
cultural milestones

Clicking an item prompts:

“Do you have a memory connected to this?”

This is one of the stickiest features in the app.

22.7 Tagging & Multi-Perspective UI

Tagging People

When user types someone’s name:

show avatar
optional relationship tag (“Mom,” “Grandpa,” “Friend,” etc.)
if the person is an app user → invite to view
if not → store them locally as “non-user person object”

Perspective Threads UI

Looks like an iMessage or chat thread but for memories.

Each person’s version appears as a separate “bubble”
AI can show “Key differences” or “Shared facts”
Users can compare versions

This makes storytelling feel collaborative and fun.

22.8 Family Vault UX

The Family Vault has:

Home Screen

Family photo (optional)
Members list (faces)
Recently added memories
Suggested shared prompts (“Tell a story about Grandma’s house…”)

Shared Albums

Vacations
Holidays
School years
Pets
Homes

Collaboration Tools

Real-time notifications
“Eric added his version—do you want to add yours?”
Tag views (“Show me all memories where both Mom and Eric were present”)

22.9 Memory Night Mode (Group Storytelling UI)

A unique feature with its own interface.

Layout:

Full-screen prompt (“Tell a story about your first job…”)
Timer (optional)
On-screen instructions: “Tap to record”
Everyone takes turns
Stories saved automatically to correct user/vault
“Next question” button

Gamification UI:

“You unlocked 3 new memories!”
“Vicki added a different version!”
Fun animations (confetti, sparkles)

This mode is high-value, emotional, and viral.

22.10 Onboarding Flow

Page 1: “Welcome to WhatHappened”

Warm messaging.

Page 2: “What would you like to remember first?”

User selects:

Myself
My parents
My kids
My grandparents
Someone else

Page 3: Capture first memory

We force a quick win.

Page 4: Tag someone

Triggers the multi-user narrative.

Page 5: Build your timeline

User enters:

birth year
hometown
major life events

Page 6: Invite family? (Soft ask)

Gentle → no pressure.

Page 7: Subscription explanation (no forced upgrade)

Transparent & friendly.

22.11 Upgrade Flow (“Soft Monetization”)

Upgrade prompts appear ONLY when the user hits natural desire points:

Tagging someone → “Invite family”
Wanting to add multiple perspectives
Wanting to build a parent’s timeline
Wanting to record audio
Wanting more AI prompts
Trying to export story bundles

The upgrade screen is soft pastels, emotional, warm:

“Preserve more than just your story.”
“Build a family legacy together.”

No pressure.
No countdown timers.
No urgency hacks.

This aligns with the brand’s emotional nature.

22.12 Visual Design System & UI Components

Color Palette

Warm neutrals
Soft blues
Pale gold accents
Gentle contrast
Never harsh colors

Typography

Rounded edges
High readability
Soft personality

Components

Memory cards
Timeline dots/cards
Category chips
People bubbles
Placeholder indicators
Audio waveform visualizer
Tag list
Prompt cards

Animations

Smooth crossfade transitions
Gentle pulsing microphone
Sliding timeline zoom
Soft bounce for celebrations

Everything must feel human, warm, and alive.

23. TECHNICAL DATA MODEL & STORAGE ARCHITECTURE

Overview

This section describes:

The core data entities (Memories, People, Timelines, Threads, Media, Prompts, Categories)
How memories relate to one another
How multiple perspectives are stored
How placeholders and incomplete memories are stored
The user → family → vault relationship hierarchy
The embedding & vector search architecture for RAG
Handling audio, images, and large binary data
Storage choices for scalability and low cost
Privacy, tenancy, and access control
Backup, export, and long-term archival considerations

This is the “engine room” of WhatHappened.

23.1 Core Principles of the Data Model

The system must support:

1. Many-to-many relationships

A single memory can involve:

multiple people
multiple perspectives
multiple categories
multiple dates (story happened vs. story told)
multiple media objects

2. Versioning

A memory can have:

raw/original version
refined/reconstructed version
multiple perspectives
updated edits
placeholder vs. completed version

3. Scalability

An average user could eventually store:

10,000–50,000 memories
100,000+ embeddings
photos, audio, and documents
multi-generational timelines

4. Multi-tenancy safety

Each user’s family vault must be isolated.

5. RAG efficiency

Memories must be chunked, embedded, searchable, and retrievable.

23.2 Database Choices

Primary Database (Transactional Data):

PostgreSQL (Recommended)
Reasons:

strong relational features
JSON support
indexing
easy horizontal scaling
works well with ORMs
supports TimescaleDB extension if needed for timeline optimization

Alternative: Aurora PostgreSQL (if using AWS)

Vector Database (Embeddings):

Qdrant, Pinecone, or pgvector extension
Recommendation:

Use pgvector inside PostgreSQL for MVP →
Migrate to Qdrant once scale grows

Media Storage:

S3-compatible storage (AWS S3 or DigitalOcean Spaces)

Objects stored:

audio files
images
video files
scans
exported PDFs

23.3 ENTITY RELATIONSHIPS (High-Level ERD)

Here is the conceptual map:

User
├── has many Memories
├── belongs to FamilyVault(s)
└── has many People entries (their network)

FamilyVault
├── has many Users
├── has many Memories
└── has many People (cross-user)

Person
├── belongs to User or FamilyVault
├── has many Memories
└── has many PerspectiveEntries

Memory
├── belongs to User or FamilyVault
├── has many PerspectiveEntries
├── has many MediaItems
├── has many Categories
├── has many Tags (People, Places, etc.)
└── has many Embeddings (chunked)

PerspectiveEntry
├── belongs to Memory
└── belongs to Person

Placeholder
├── belongs to Memory
└── has fields for “complete/incomplete”

MediaItem
├── belongs to Memory
└── stores S3 URL + metadata

TimelineEvent
├── belongs to Person
├── belongs to Memory
└── can be user-created (school, home, job)

WorldEvent
└── global, read-only, referenced by many Memories

23.4 TABLE SCHEMAS

Below are simplified schemas for clarity.
Engineering will expand these later.

Table: users

id (PK)
email
password_hash
name
birth_year
profile_photo_url
created_at
updated_at
subscription_tier
family_vault_id (nullable)

Table: family_vaults

Table: people

This includes:

the user
family members
grandparents
historical people
deceased loved ones
people added during memory creation

id (PK)
family_vault_id (nullable)
user_id (nullable) — owner of this person object
name
relationship_to_user
birth_year (nullable)
death_year (nullable)
profile_photo_url
metadata_json
created_at
updated_at

23.5 MEMORIES TABLE (The Heart of the System)

Table: memories

id (PK)
user_id (nullable)
family_vault_id (nullable)
title
raw_text
refined_text
date_start
date_end
location
is_placeholder (boolean)
status (complete | placeholder | needs_review)
created_at
updated_at

Notes:

raw_text = original voice transcription or typed text
refined_text = edited AI-generated version
date_start and date_end handle fuzzy or approximate dates
Ownership depends on whether memory is personal or shared

23.6 MULTIPLE PERSPECTIVES

Table: perspective_entries

id (PK)
memory_id (FK)
person_id (FK)
text
audio_url (nullable)
created_at
updated_at

This allows:

unlimited perspectives
separate voices
independent edits
threads within one memory

23.7 PLACEHOLDERS & INCOMPLETE MEMORIES

Table: placeholders

id (PK)
memory_id (FK)
placeholder_text
priority_level (low/normal/high)
remind_at (nullable)
created_at
updated_at

This supports the system’s ability to:

remind the user
generate new prompts
keep track of incomplete stories

23.8 MEDIA HANDLING

Table: media_items

id (PK)
memory_id (FK)
media_type (image | audio | video | document)
s3_url
thumbnail_url
file_size_bytes
metadata_json (EXIF, duration, etc.)
created_at

Media Processing Pipeline:

User uploads → temporary storage
Resized + optimized versions created
Audio transcribed
Stored in S3
Linked to memory entry

23.9 TAGGING SYSTEM

There are three types of tags:

Category tags (Trips, Homes, Pets, School, etc.)

Table: categories

id
name
created_at

Person tags

Many-to-many relationship:

Table: memory_people

memory_id
person_id
role (optional)

Custom tags

Table: tags

id
name
created_at
created_by_user_id

Table: memory_tags

memory_id
tag_id

23.10 TIMELINE SYSTEM

Timeline events come from three sources:

memories
user-added life events (homes, schools, jobs, pets)
world events

Table: timeline_events

id (PK)
person_id (FK)
memory_id (nullable)
title
event_type (home, job, school, pet, life_event, world_event)
date_start
date_end
description
created_at
updated_at

Table: world_events

id (PK)
title
category (music, movies, politics, etc.)
description
date
metadata_json

These events can be referenced dynamically, not copied.

23.11 RAG & VECTOR SEARCH ARCHITECTURE

Embedding Strategy:

Each memory produces multiple chunks:

title
raw text chunks
refined text chunks
perspective entries
tags
summaries
context metadata

All chunks go into:

Table: memory_embeddings

id (PK)
memory_id (FK)
chunk_text
embedding_vector
chunk_type (raw, refined, perspective, summary, metadata)
created_at

Vector fields stored via pgvector or Qdrant.

Retrieval Pipeline:

User search → semantic query embedding
Vector similarity search (top 20)
Rerank based on:
- recency
- relationship to query
- person weighting
- timeline context
Returned to user as memory cards

23.12 FAMILY PERMISSIONS & ACCESS CONTROL

At the family vault level:

family_vault_members

id
family_vault_id
user_id
role (owner, contributor, viewer)
permissions_json

Rules:

Owner can remove members
Contributors can add/edit memories
Viewers can only read
Memories tagged with “private” field visible only to creator

23.13 STORAGE COST OPTIMIZATION

Media Storage:

S3 lifecycle policies:

Frequent access → Glacier after X years
Keep thumbnails for fast loading

Database:

Cold memories archived to cheaper storage
Embeddings for inactive memories compressed

Optional:

User could pay for “permanent archival mode” for deceased relatives.

23.14 BACKUP & EXPORT ARCHITECTURE

Backups:

Daily full backup
Hourly WAL logs
Monthly deep archival snapshot

Export Options:

JSON bundle (all memories, media URLs, metadata)
PDF “Life Book”
Audio anthology

Long-Term Legacy Storage:

Legacy tier guarantees long-term hosting:

10–50 years retention
redundancy across storage zones

23.15 FUTURE EXPANSIONS OF DATA MODEL

1. AI-Synthesized Voices

Store voice prints for reconstruction.

2. VR/AR Timeline

3D event mapping.

3. Life Graph

Visual relationship graph (people → stories → places).

4. Memory Strength Index

Weighted scoring for important memories.

5. Sentiment tracking

Emotional arcs in a life story.

24. DEVELOPMENT ROADMAP & ENGINEERING PHASES

Overview

This section defines:

MVP (Minimum Viable Product)
Alpha, Beta, and Full Launch
Engineering sprints and workload planning
Feature dependencies and sequencing
Infrastructure and devops timeline
QA, testing, and polish cycles
Launch-readiness checklist
Post-launch roadmap (12–24 months)

This answers:
“What gets built first, second, and third — and why?”

24.1 Product Philosophy for Development

Three guiding principles govern the build:

1. Capture > Organize > Enrich > Share

We build outward from the core:

Capture memories →
Organize memories →
Enhance/Refine memories →
Share and collaborate

2. Get users capturing memories fast

The MVP must deliver a magical “first-memory moment” within 30–60 seconds.

3. Build the memory engine first, the polish later

Early users will tolerate rough edges.
They will not tolerate slow capture, lost data, or confusing organization.

24.2 Build Phases Overview

Phase 0 – Foundation Setup (2–3 weeks)

Infrastructure
Database seed schemas
Authentication
Basic user accounts
Core backend architecture

Phase 1 – MVP Build (8–10 weeks)

Goal: Collect raw memories reliably and place them on a timeline.

Includes:

Text memory capture
Placeholder system
Basic tagging
Basic person creation
Basic timeline
Photo upload
Simple memory viewer
Editing tools
World-events timeline (Phase 1: shallow list, no RAG link)
Essential RAG infrastructure (but minimal UI)
Family Vault scaffolding (no collaboration yet)
Basic onboarding
Export (single-memory PDF)
Error states, autosave, drafts

Does NOT include:

voice capture
family collaboration
multiple perspectives
Memory Night mode
complex prompts
full world timeline
refined text generation
AI enhancements

This version is purely functional, not luxurious.

Phase 2 – Alpha (6–8 weeks)

Goal: Real users can store real memories.

Add:

Voice recording + transcription
Date estimation
Location tagging
Timeline polish
Placeholder reminders
Tagging refinement
RAG search UI
Early AI summarization tools
Begin multi-generational timeline model
Early family vault UI (no invitations yet)

Alpha = usable but unpolished.

Used by:

founding families
internal testers

Phase 3 – Private Beta (8–12 weeks)

Goal: Collaboration becomes real; the product feels magical.

Add:

Family Vault invitations
Multi-perspective memories
Memory thread UI
People tagging interface
AI prompt engine (version 1)
Full world timeline overlay
Memory Night mode (early version)
Export bundles (PDF, audio)
UX refinement
Better onboarding
More RAG filters (people, places, emotions)
Account upgrade/paywall gating
Subscription infrastructure (Stripe/Apple/Google)

This is the phase where belief becomes product.

Phase 4 – Public Beta (6–10 weeks)

Goal: Scale from hundreds to tens of thousands of users.

Add:

advanced AI refining tools
AI story-stitching
Family sharing/publishing tools
Rich media gallery
Photo clustering on timeline
Sentiment detection
AI “memory extraction” from long recordings
Prompt sequences (interview mode)
Performance optimization
Help center + support workflows
Announcements & notifications system
Stability hardening
Accessibility improvements

This version is nearly launch-ready.

Phase 5 – Full Public Launch (4–6 weeks)

Goal: A stable, delightful, emotionally resonant consumer app.

Includes:

polished onboarding
bug-free memory capture
delightful timeline UI
user-motivating prompt flows
refined subscription screens
reliable exports
strong family vault admin controls
scalable RAG infrastructure
marketing integration (deep links, tracking pixels)

This phase is about polish, reliability, and emotional experience.

24.3 Engineering Sprints Breakdown (12–18 month plan)

Assuming 2-week sprints:

Sprint 1–2: Infrastructure

Repo setup
CI/CD pipeline
PostgreSQL + pgvector
File storage (S3)
Core API framework

Sprint 3–6: MVP Core

Text memory creation
Memory retrieval
Basic timeline
Placeholders
People tagging
Photo attachments
Authentication
Account management
Basic RAG engine

Sprint 7–10: Alpha Features

Voice recording
Transcription pipeline
Date extraction
Metadata tagging
Enhanced timeline UI
Early AI summarization

Sprint 11–16: Private Beta Features

Family Vault backend
Multi-perspective system
Threaded memory UI
Word-event overlay
Prompt engine
Memory Night mode
Invite flow
Stripe integration

Sprint 17–20: Public Beta Features

AI story stitcher
Export bundles
Gallery view
Performance tuning
Search refinements
Notification system

Sprint 21–24: Launch Polish

UX smoothing
Crash fixing
Onboarding improvements
Internationalization hooks
Marketing site integration
App Store & Play Store submission

24.4 Dependencies & Build Sequencing Logic

1. Capture must come before collaboration.

You cannot collaborate on memories that do not exist.

2. Timeline must work before world overlay.

The overlay depends on the timeline scaffolding.

3. Multi-perspective storage depends on:

memories table
people tagging
vault permissions

4. AI features depend on:

reliable memory storage
working embeddings pipeline
minimal retrieval UI

5. Subscription system depends on:

defined pricing tiers
feature gating

6. Memory Night mode depends on:

collaboration infrastructure
prompt engine

Everything builds on the previous layer.

24.5 Infrastructure Roadmap

Initial Tech Stack (MVP – Alpha):

Frontend: React Native or Flutter
Backend: Node.js or Python (FastAPI)
Database: PostgreSQL + pgvector
Media: AWS S3
DevOps: Docker, GitHub Actions
Logging: CloudWatch or Datadog
Transcription: Whisper API
AI: OpenAI + custom prompt engine

Public Beta → Launch Stack Enhancements

CDN for faster media delivery
Caching layer (Redis)
Background job system (Celery, Sidekiq, etc.)
Dedicated vector DB (Qdrant) if needed
Advanced monitoring
Backups & archival pipelines

24.6 QA & Testing Phases

Alpha Testing

Founding Families
Internal testers
All flows manually tested
Significant bug tolerance

Private Beta QA

Device compatibility testing
Load testing
Data durability tests
Performance profiling

Public Beta QA

Full test suite
Regression testing
RAG retrieval stress tests
Audio pipeline stability
Timeline rendering performance

Launch QA

App Store compliance
No crashes in memory creation
Smooth onboarding
Payment reliability
Offline mode sanity checks

24.7 Launch Readiness Checklist

Before launch:

Must-Have Reliability

❑ Voice → Transcription → Saved Memory
❑ Text memories save instantly
❑ Media upload stable
❑ Timeline loads without lag
❑ RAG search consistently returns correct items

Must-Have Emotional Hooks

❑ First memory capture feels magical
❑ Prompt engine is warm and non-intrusive
❑ Family tagging works perfectly
❑ Memory Night is fun and smooth

Must-Have Business Readiness

❑ Subscription system stable
❑ Welcome/onboarding email flows
❑ Privacy policy + data model documentation
❑ Easy export of memories

Must-Have Infrastructure

❑ Backups in place
❑ Error logging
❑ Scaling limits tested

24.8 Post-Launch Expansion Roadmap (12–24 Months)

Phase A – Engagement Enhancements

Streaks (gentle, optional)
Memory prompts by season/date
AI “memory prediction”
Pet memories module
Recipe memories module

Phase B – Advanced AI Capabilities

Persona-based storytelling (“Tell this story as if to a child”)
Audio biography generation
Voice cloning for deceased loved ones
Memory refinement loops

Phase C – Legacy & Memorial Features

End-of-life capture kit
Memorial pages
AI-curated “Life Highlights” reel
Digital inheritance

Phase D – Community & Sharing

Optional public stories
Memory Walls for events
School partnerships
Couples story mode

Phase E – Enterprise

Retirement home integration
Corporate legacy programs
Hospice partnerships
Generational diversity programs

24.9 Staffing Recommendations (Lean Startup Model)

Core Team (MVP – Public Beta):

1 Product Manager (half-time is fine)
1 Senior Backend Engineer
1 Senior Mobile Developer
1 ML/AI Engineer
1 UI/UX Designer
(Optional) DevOps contractor
(Optional) QA tester

Post-Launch Team:

2–3 additional mobile devs
1 additional backend dev
Dedicated QA lead
Customer support part-time
Marketing & community role

25. Conclusion & Founders’ Vision

At its core, WhatHappened began as a deeply personal project — a way for Eric Johnson and his sister, Vicki Johnson, to capture the stories, memories, and life moments that shaped their family. Long before we thought of markets, pricing tiers, or AI pipelines, we simply wanted a tool we wished already existed: a place where memories could be stored, organized, revisited, shared, and cherished across generations.

In the earliest stages of development, Eric and Vicki will carry the bulk of the work themselves — designing the structure, shaping the prompts, testing the capture experience, and refining the AI memory engine. This is intentional. The product must feel intimate, intuitive, and emotionally safe before it ever reaches the public. And nothing exposes flaws or reveals magic faster than using the tool on your own family history.

Once the foundation is solid, we will expand initial testing to Laura Vigil’s family. Laura — Eric’s wife — and her extended family will help validate the multi-perspective features, Family Vault dynamics, and storytelling workflows. Their involvement gives us diversity of experiences, ages, memory styles, and cultural backgrounds. This will pressure-test the system in ways that single-family testing cannot.

From there, the roadmap is simple but profound:

Build this for ourselves first
If it doesn’t move us, delight us, and help us capture our own lives, it won’t work for anyone else.
Refine it until it becomes effortless
Users should feel like the tool fades into the background and the memories take center stage.
Only then consider scaling it to others
When the system reliably captures the complexity and beauty of our own family’s stories, we will invite others to experience that same magic.

Even in the unlikely scenario that WhatHappened never grows into a major consumer platform — even if it never earns a cent — the “worst-case” outcome is actually remarkable:

We will have created the most comprehensive, meaningful, and emotionally rich record of our family’s history that has ever existed.

We will have preserved thousands of stories that would otherwise fade.
We will have built tools that future generations of the Johnson and Vigil families can cherish.
We will have experimented with the frontier of AI not just as a technical exercise, but as a way of strengthening human connection.

And if the best-case scenario comes true — and we have every reason to believe it can — WhatHappened will become a mass-market phenomenon, a platform that helps millions of people preserve their stories, learn from their pasts, celebrate their lives, and connect with the people who matter most.

This project blends legacy, technology, psychology, anthropology, and family love into something entirely new. It is both a startup and a gift — one we are giving to ourselves first, and hopefully, someday, to the world.