Still

STILL — Turn family photos into memories, stories, and history.

Comment 1

STILL — About the Project

Inspiration

I started building STILL because I kept thinking about how differently we treat the photos that matter most to us.

Most of the photos we take end up buried in a camera roll. You might remember the photo, but not necessarily the story behind it: who was there, where it happened, or why that particular day was important.

I wanted to build something where a family could keep those things together.

Not another social network. Not another photo gallery.

Something private where you could actually build a history of your family.

That idea became STILL.

The more I thought about it, the more I realized that a family memory isn't really a photo. It's the people, place, date and story around it.

That became the foundation of the app.

What it does

STILL is a private space where families can preserve and explore their memories together.

A family can:

  • Create profiles for family members
  • Save memories with stories, dates and locations
  • Attach people to memories
  • Store photos, video and audio
  • Explore memories on a map
  • Browse their history through a timeline
  • Build an interactive family tree
  • Share everything privately with other family members

The Family Tree was particularly important to me because it doesn't depend entirely on the People section.

You can add someone to the tree even if they don't have a profile in the app, and link existing people when appropriate.

So instead of just having:

People → Profiles

You get:

People → Relationships → Generations → Memories

That's much closer to how families actually remember things.

How we built it

STILL is a native Android application built with Kotlin and Jetpack Compose, designed from the beginning around an offline-first architecture.

The goal was simple: the app should remain usable even when there is no internet connection.

Architecture

STILL uses a layered architecture with unidirectional data flow, keeping the UI independent from the backend.

The main layers are:

  • Jetpack Compose — UI
  • ViewModels — UI state and events
  • Use Cases — application logic
  • Repositories — data abstraction
  • Room — local database and source of truth
  • Sync Engine — local/remote synchronization
  • Supabase — backend and remote data
UI → ViewModel → Use Cases → Repository → Room
                                              ↓
                                         Sync Engine
                                              ↓
                                           Supabase

Challenges

The hardest part of STILL wasn't building a particular feature.

It was building an app that could be simple enough for the whole family to use, while still being powerful enough to actually preserve a family's history.

STILL isn't designed around a typical tech-savvy user. A family might have someone who spends all day on their phone alongside someone who rarely uses apps at all.

That changed the way I approached the UI.

I had to constantly ask myself:

"Could someone who isn't comfortable with technology understand what to do here?"

This meant reducing unnecessary steps, keeping navigation predictable, making important actions obvious, and avoiding interfaces that felt overloaded with options.

At the same time, the app needed to remain functional on older or less powerful Android devices. That meant being careful with image loading, local caching, database operations and unnecessary work on the main thread.

The goal wasn't to make the simplest app possible.

It was to make something that felt simple to use without being simple underneath.

🔄 Making Offline-First Actually Work

The second major challenge was synchronization.

The idea sounds straightforward:

Save locally
    ↓
Sync when online.

Another challenge was permissions.

STILL contains very personal family information, so I couldn't just make everything accessible to everyone in a family.

I ended up with different family roles:

  • Owner
  • Caregiver
  • Member
  • Viewer

and used Supabase Row Level Security to enforce those permissions on the backend rather than relying on the Android client.

Accomplishments I'm Proud Of

First and foremost, I'm proud that I actually managed to turn the original idea into a working application and get it ready for its first Google Play release.

What started as a simple idea around family memories ended up becoming a full offline-first application with:

  • Family accounts and roles
  • Offline data and synchronization
  • Private media storage
  • Interactive family trees
  • Maps and timelines
  • Push notifications
  • Multiple types of media

I'm particularly proud of the synchronization system. It would have been much easier to build STILL as an online-only application, but making Room the local source of truth forced me to solve a much more interesting set of problems around reliability and consistency.

What's Next for STILL

The current version is only the foundation.

The next thing I want to explore is making the family's existing memories interactive instead of simply storing them.

For example:

  • Memory quizzes based on the family's own photos
  • "Who is this?" experiences
  • Questions about places and events
  • Reminiscence activities
  • Stories generated from existing memories
  • Connections between memories from different generations

I'm especially interested in how these features could help families use STILL together rather than simply storing their memories and leaving them untouched.

The goal isn't to replace human memories with AI.

It's to use AI to make the memories a family has already preserved more engaging and easier to revisit.

Built With

Share this project:

Updates

Submission history