Inspiration
Still started with a simple question:
What happens when someone needs help right now, but the tool meant to help them creates even more friction?
A lot of wellness apps expect you to create an account, answer questions, navigate several screens, or send personal information to a server before they become useful.
That felt backwards for the kind of moments Still is built for.
Still is designed for moments when someone is trying to interrupt an unwanted urge or habit. The goal is not to diagnose the user or pretend to replace professional care. The goal is much smaller and more practical: help someone get through the next few minutes.
Breathing. Grounding. A quick log. A distraction. A chance to stop and make a different choice.
I also wanted the app to feel genuinely private. Recovery data can be extremely personal, so I did not want the core product to depend on uploading that history to a cloud service.
That became one of the main principles behind Still:
If the information is deeply personal, the app should have a very good reason before it leaves the user's device.
What it does
Still is a local-first mobile recovery and urge-interruption app.
When someone is struggling with an urge, they can quickly open the app and use tools such as:
- guided breathing
- grounding exercises
- urge logging
- interruption tools
- offline calming soundscapes
- progress tracking
- private recovery history
For Hack for Humanity, I focused heavily on making the app useful beyond a simple streak counter.
I built a private recovery dashboard that can summarize the user's own history, including:
- resisted or interrupted urges
- reset events
- grounding sessions
- activity over the last seven days
- commonly logged triggers
- the time periods when the user logs the most urges
One detail I cared about a lot was how those insights are presented.
Still does not say:
"You are likely to relapse tonight."
Instead, it might say:
"Evening is your most logged time period."
That may sound like a small wording difference, but it represents an important product decision.
Still shows patterns from the past, not predictions about the person.
How we built it
Still is built with React Native, Expo, Expo Router and TypeScript.
The core application is designed to work locally instead of requiring a traditional cloud backend.
I use SQLite for structured local history and SecureStore for sensitive values. The app also uses native capabilities for features including:
- haptic feedback
- local authentication
- audio
- notifications
- secure storage
- screen-capture protection
- sharing
- camera-based experiences
During the hackathon period, I also built an on-device analytics layer.
The analytics are intentionally simple and transparent. The app calculates things like trigger frequency, seven-day activity, success and reset counts, streak information and time-of-day patterns from the user's own records.
There is no need to upload the raw recovery history to an analytics server just to generate those insights.
I also added offline soundscapes so one of the app's calming tools continues working without streaming audio from the internet.
A major technical rule throughout the project was:
The important parts of Still should continue working when the network disappears.
Challenges we ran into
Making insights useful without pretending they are medical predictions
This was probably the most interesting challenge.
Once an app has behavioral data, it becomes very easy to make the interface sound more intelligent than the underlying information actually is.
If six of someone's ten recent logs happened at night, that is useful context.
It is not proof that something will happen tonight.
I had to think carefully about where the line was between helpful personalization and fake certainty.
I decided Still should prefer being slightly less impressive over being misleading.
Keeping sensitive data local
A cloud backend would have made several things easier.
Synchronization would be easier. Analytics would be easier. Cross-device access would be easier.
But it would also mean creating a centralized copy of very sensitive recovery information.
Building local-first meant dealing with more work myself: persistence, secure values, deletion, failure handling, state recovery and analytics.
For this product, I think that tradeoff is worth it.
Designing for a bad moment
Another challenge was remembering that Still is not primarily used when someone is relaxed and casually exploring an app.
Someone may open it during a moment where their attention and patience are both low.
That meant repeatedly asking:
How many actions stand between opening the app and getting help?
I tried to keep the interruption tools quick to reach and avoid unnecessary decisions.
Edge cases that look boring until they break
Some of the hardest work was not flashy.
Timers have to survive correctly.
Streak calculations have to handle dates properly.
Logs cannot disappear because of a persistence error.
Deleting private data has to actually delete the data.
The app also needs honest empty and error states instead of silently showing incorrect information.
A large part of improving Still was dealing with those less visible problems.
Accomplishments that we're proud of
I am most proud that Still became more useful without becoming more invasive.
During the hackathon period I added or substantially improved:
- the private recovery dashboard
- local progress analytics
- seven-day recovery summaries
- trigger-pattern insights
- time-of-day pattern insights
- offline generated soundscapes
- breathing and interruption reliability
- urge-log persistence
- streak handling
- privacy controls
- local-data deletion behavior
- error and recovery states
The analytics dashboard is especially important to me because it demonstrates that personalization does not automatically require cloud profiling.
I am also proud that the product is careful about its limits.
Still does not claim to diagnose addiction, predict someone's behavior, or replace professional treatment.
It is a tool meant to support one decision at a time.
What we learned
The biggest thing I learned is that responsible technology is not always about making a system more intelligent.
Sometimes it is about knowing where not to use intelligence.
A pattern does not have to become a prediction.
A personal history does not have to become a cloud profile.
A recovery tool does not have to pretend it understands someone's entire mental state.
I also learned that privacy architecture directly changes the product experience.
"Local-first" is not just something I can write on a privacy page. It affects storage, analytics, backups, deletion, authentication and almost every engineering decision in the app.
And I learned how much engineering hides inside features that look simple from the outside.
A streak number is really date logic and persistence.
A breathing timer is really lifecycle and state management.
A delete button is really a promise that the user's information is actually gone.
Those details ended up mattering just as much as the visible features.
What's next for Still
I want to continue improving Still around three principles:
Immediate usefulness Reduce the time between opening the app and reaching something that can help.
Privacy by default Keep processing and personal history on the user's device whenever practical.
Honest personalization Help users understand their own patterns without pretending the app can diagnose or predict them.
Future work includes better accessibility, additional evidence-informed grounding exercises, improved recovery planning, optional encrypted backup and easier user-controlled data portability.
The long-term idea behind Still is simple:
A deeply personal app should not require giving up deeply personal data in order to be useful.
Log in or sign up for Devpost to join the conversation.