Week 1: Turning a Reminder Idea into an MVP Scope

Build in Public — Week 1 (April 20–April 26)

When I first started thinking about Lumi, the idea was much bigger than a reminder app. In my notes, the early concept looked closer to a personal assistant: voice conversation, reminders, long-term memory, emotional support, active follow-up, user profiles, maybe even family-related scenarios. It sounded exciting— but there were some technical challenges, and it was simply too big.

As a solo developer building a first product, the real question was not “What could this become one day?” The real question was:

What is the smallest version that can prove the product is useful?

That question turned a vague idea into an MVP.

The first idea was broad

The original direction came from a very human problem: people forget small but important things. For older people, that might be medicine, injections, appointments, dressing properly before going out, or remembering keys. For busy adults, it might be meetings, bills, calls, health routines, or small personal commitments. Once I started thinking about “personal assistant,” many ideas appeared quickly:

• voice input
• voice replies
• local conversation history
• reminders
• recurring schedules
• emotional understanding
• long-term memory
• user preferences
• proactive follow-up
• family or caregiver support
• stronger notification modes.

This is the dangerous part of early product thinking. A real problem can generate many possible features. But features are not a product. A product needs a clear first loop.

I had to cut aggressively

Some ideas were attractive but not suitable for the first version. For example, voice identity recognition sounded interesting. But it would introduce accuracy, privacy, and technical complexity. It was not needed to prove whether people wanted a conversational reminder assistant. Proactive emotional support also sounded valuable. But it would require careful design, testing, and user trust. It was not the right first step.

Family support could become meaningful later, especially for elderly care. But it would add accounts, permissions, cloud sync, and more compliance concerns. The same was true for a full “AI agent” vision. It is easy to say that an assistant should eventually do many things. But if the first version cannot reliably do one thing, the bigger vision does not matter. So I cut the scope down. The first version would focus on reminders.

Reducing a broad personal assistant vision to a focused reminder MVP

Why reminders?

I chose reminders because they create a complete and testable product loop. A reminder has a clear input:

Remind me to take medicine tomorrow morning.

It has a clear output: The app creates a reminder and notifies the user at the right time. It also has clear management actions:

• edit it
• delete it
• pause it
• resume it
• check what is coming today.

This made reminders a good MVP target. It was not too small, because reliable reminders are genuinely useful. It was not too broad, because the first version did not need to solve every personal assistant scenario. It was a narrow loop with real value.

The MVP was not “a chat app”

One of the most important decisions was this: Lumi should not be just a chatbot. A chatbot can answer. A product must act. For Lumi, the assistant needed to turn language into a working reminder. That meant the MVP had to include more than a conversation screen. It needed:

• natural language input
• task creation
• recurring reminder support
• manual task management
• local storage
• notification behavior
• basic history
• settings
• enough testing to trust the reminders.

This was still a lot for one person. But it was a real product loop. The chat interface was only the entry point. The product value came from what happened after the user said something.

I kept manual controls on purpose

Another important decision was to keep manual controls. It might sound more “AI-native” to make everything conversational. But that is not how people use tools every day. Sometimes typing is faster. Sometimes tapping is clearer. Sometimes the user wants to inspect the task details before saving. Sometimes AI may misunderstand. So Lumi needed both:

• talk to create or manage reminders quickly
• tap to review, edit, or control them directly.

This was not a compromise. It was a product principle. AI should reduce effort. It should not remove control.

I also had to define what not to build

MVP planning is not only about choosing features. It is also about choosing what to leave out. For the first version, I decided not to start with:

• full cloud sync
• multi-user family accounts
• voice identity
• emotional companion features
• advanced analytics
• a broad automation platform
• every possible integration.

Some of these may be useful later. But adding them too early would make the product harder to build, harder to test, and harder to explain. The first version needed a simple promise:

Tell Lumi what you need to remember, and it helps turn that into a reminder.

That was enough.

The product had to be useful before it was impressive

There is a temptation in AI products to make them sound impressive. Agent. Memory. Automation. Multi-modal. Personal intelligence. Those words are attractive, but they can also hide the basic question:

Does this help the user do something they actually need?

For Lumi, the answer had to come from a simple daily task. If the app could not help someone reliably remember medicine, appointments, calls, or routines, then a larger AI story would be meaningless. So I tried to make the MVP useful before making it impressive. That shaped many decisions:

• no sign-up requirement for the first experience
• local-first data direction
• clear reminder views
• manual fallback
• focus on reminder reliability
• simple product language.

What I learned in week 1

The hardest part of MVP planning was not technical. It was emotional. When you are building your first independent product, every idea feels important. Every possible feature feels like it could make the product better. Cutting scope feels like losing value. But the opposite is usually true. Scope is not value. Focus creates value. For Lumi, the MVP became clear only after I accepted that the first version did not need to be a full personal assistant. It needed to be a useful reminder assistant.

That distinction gave me a path forward. The bigger vision could wait. The first loop had to work. So Week 1 was about turning a broad idea into a smaller promise:

Lumi helps you capture reminders in natural language and manage them with control.

That was the first real product boundary. And for a solo developer, a clear boundary is not a limitation. It is what makes shipping possible.