Stillpoint started as a small personal project with a very specific goal: build a private yoga app for a small group of intermediate practitioners who wanted a simple way to structure their daily sessions.

Instead of trying to create a large public fitness platform, I focused on something more useful: a lightweight app that could suggest a daily practice, remember what had already been done, and gradually adapt future recommendations.

The result is Stillpoint, a private Progressive Web App built with React, Vite, Supabase and Netlify.

The Idea

The main question behind Stillpoint was simple:

Can a yoga app provide useful daily recommendations without relying on a paid AI API or a complex machine-learning model?

For this project, I decided that it could.

Instead of calling an external AI service every day, Stillpoint uses a rule-based recommendation engine. The system looks at each user's own practice history and builds a short routine based on what they have recently completed, what they may have neglected during the week, and the difficulty level they selected.

This approach keeps the system fast, predictable and inexpensive to run.

More importantly, the recommendations remain explainable.

How the Daily Practice Works

When a user opens the home screen, Stillpoint generates a short daily yoga sequence.

A typical session contains:

  • A warm-up
  • A small number of main poses
  • A cool-down

The recommendation engine looks at the user's personal practice log before selecting the poses.

It tries to avoid repeatedly recommending poses that were performed recently. It also looks for categories that may have been underrepresented during the week and gives them greater priority.

The selected difficulty level also influences the recommendation.

This means that tomorrow's practice is partially shaped by what the user actually does today.

Difficulty Is More Than a Simple Filter

Stillpoint supports three difficulty settings:

  • Beginner
  • Intermediate
  • Expert

Beginner mode is strict and only selects beginner-level poses.

Intermediate and Expert work differently. Their selected level acts as a maximum difficulty ceiling rather than forcing every pose to be difficult.

That distinction is important because a sensible practice should still contain gentle movements.

An expert practitioner does not necessarily need an expert-level warm-up or cool-down.

The recommendation engine can therefore combine easier preparation poses with more demanding main poses while respecting the user's selected level.

From Recommendation to Guided Practice

Each recommended pose can be opened individually.

The pose page includes:

  • An illustration or image
  • A description of the pose
  • Its main benefits

Once the user is ready, they can select Start Practice.

Stillpoint then turns the recommendation into a simple step-by-step carousel, allowing the user to move through the sequence without constantly returning to the main screen.

I wanted this part of the interface to remain intentionally simple.

The application should support the practice rather than become the focus of it.

The Yoga Catalogue

The current Stillpoint catalogue contains 172 yoga poses.

The collection is divided into:

  • 64 beginner poses
  • 66 intermediate poses
  • 43 expert poses

Descriptions and benefits have been written for the full catalogue.

The original 48 poses also include finished illustrations.

The newer poses currently use temporary placeholders while the visual catalogue is expanded.

The long-term goal is to replace these placeholders with a more consistent custom illustration style so the catalogue feels visually coherent and personal.

Logging the Practice

Recommendations are only useful if the application knows what the user actually completed.

Stillpoint therefore includes a separate calendar and practice logging system.

After completing a session, users can record the poses they performed using a checklist.

Those logs serve several purposes.

They create a history of the user's practice, contribute to their practice streak, and feed information back into the recommendation engine.

That creates a simple feedback loop:

Recommendation → Practice → Log → Next Recommendation

The application does not need a complex predictive model to become more personalised over time. A carefully designed rules engine can already create useful adaptive behaviour when it has access to consistent historical data.

Privacy and Per-User Data

Stillpoint was designed as a private application from the beginning.

Authentication and data storage are handled using Supabase.

Each user's practice history and associated information are protected using Row Level Security (RLS) policies.

This means that users share the same application infrastructure while their personal records remain isolated.

For a relatively small project, this architecture still provides many of the same patterns used in larger production systems:

authentication, persistent data, user isolation, access control and cloud deployment.

Breathing and Ambient Sound

Yoga is not only about moving between poses, so I also wanted Stillpoint to include a quieter element.

The home screen contains an interactive breathing guide that users can follow independently from the recommended practice.

I have also experimented with optional ambient sound.

The sound system is still evolving, but it is an interesting feature because it can improve the atmosphere of the application without interfering with the main practice experience.

Progressive Web App

Stillpoint is configured as a Progressive Web App, which means it can behave more like an installed application on supported devices while still being developed and deployed as a web project.

For small personal applications, I like this approach because there is no separate native mobile codebase to maintain.

The core stack remains straightforward:

React + Vite → Supabase → Netlify

It is a combination that allows me to move quickly while still implementing proper authentication, persistent data, security rules and deployment workflows.

What I Learned from Building It

One of the useful lessons from Stillpoint is that not every recommendation system needs machine learning.

There is a tendency to assume that anything described as personalised or intelligent requires an LLM or predictive model.

Sometimes it does.

But sometimes the underlying problem can be described clearly enough that deterministic rules provide a better solution.

Stillpoint already knows several useful things:

  • What the user practised recently
  • Which categories they have neglected
  • Their selected difficulty
  • Which poses belong to each category
  • Which poses are appropriate for their level

Once those relationships are defined properly, a rule-based recommender can make useful decisions.

It is also transparent. If a recommendation feels wrong, I can trace the logic that produced it instead of trying to interpret an opaque model output.

Current Status

Stillpoint is currently live and being tested by its intended users.

At this stage, development is focused on improving reliability, refining the recommendation logic, expanding the visual catalogue and using real-world feedback to guide future changes.

Rather than continuously adding features, I want the next version to be shaped by actual usage.

For me, that is one of the most important stages of any project.

The code can tell me whether the application works.

Real users tell me whether it is useful.