I have a complicated relationship with to-do apps.
I love trying them.
I love reading about productivity systems.
I love seeing beautifully designed task lists, calendars, tags, projects, priorities, integrations, dashboards, and all the other things that promise to help me become more organized.
But eventually, something always bothered me.
The task manager itself started becoming a task.
Create an account.
Create a project.
Create a list.
Choose a workflow.
Configure your settings.
Connect your calendar.
Learn how everything works.
And then, finally, add the thing you actually wanted to remember.
At some point I thought:
What if a task manager just let me manage my tasks?
So I built one.
It's called Wumilo.
Your tasks. Your focus. Your phone.
Wumilo is an Android task manager built around a fairly simple idea:
A productivity app should help you finish things, not give you another system to maintain.
When you open Wumilo, you can start typing immediately.
No account setup.
No onboarding questionnaire.
No complicated workspace configuration.
Just add a task.
For example:
Call Mom tomorrow at 3pm
Instead of making you fill out several fields, Wumilo can understand the task and turn it into something with the appropriate date and time.
You can also add tasks using your voice.
The goal isn't to make task management smarter for the sake of being smarter.
It's to make getting something out of your head and into your task list feel almost effortless.
I Didn't Want to Build Another Productivity System
There are already countless excellent task managers.
Some are incredibly powerful.
Some are designed around projects.
Some are built around calendars.
Some are designed for teams.
Some give you an almost unlimited number of ways to organize your life.
That's great.
But I wanted to build something different.
The question I kept coming back to was:
What is the minimum amount of friction between thinking about something and getting it into your task list?
That's the experience I wanted to optimize.
Of course, Wumilo still has the features you'd expect from a proper task manager:
- Subtasks
- Notes
- Priorities
- Categories
- Reminders
- Recurring tasks
- Widgets
- Voice input
- Progress tracking
But features shouldn't become the experience.
The basic interaction should still be:
Open the app → add the task → get on with your day.
Focus Mode
One of the features I care about most is Focus Mode.
A normal task list can quickly become overwhelming.
You open the app and see twenty things.
Then thirty.
Then fifty.
Everything feels important because everything is sitting there looking at you.
So instead of constantly showing the entire backlog, Focus Mode tries to answer a much simpler question:
What should I finish right now?
It puts one important task in focus instead of asking you to mentally process your entire list.
It's a small change, but I think there's something important about it.
A task manager shouldn't only help you remember what you need to do.
It should also help you decide what deserves your attention right now.
Privacy Wasn't an Afterthought
Another thing I wanted from the beginning was privacy.
A task list can contain surprisingly personal information.
Things you need to remember.
People you need to call.
Bills you need to pay.
Appointments.
Ideas.
Work.
Personal plans.
I kept asking myself:
Does this data actually need to leave the phone?
If the answer is no, why should it?
Wumilo is designed to work without requiring an account or cloud service just to manage your tasks.
Your task manager should feel like something that belongs to you and your phone, rather than another service you have to maintain.
Reminders Are More Complicated Than They Look
This was one of the biggest surprises for me.
A reminder sounds simple.
You create a task.
You choose a time.
The phone reminds you.
Easy, right?
Not quite.
On Android, reminders can involve alarms, permissions, notifications, battery optimization, manufacturer-specific behavior, Android version differences, and operating-system decisions that can affect how reliably something fires.
Then you start testing on actual devices.
And suddenly, something that seemed like a tiny feature becomes an entire engineering problem.
I've had users report reminders arriving late or behaving differently on their particular devices.
That's when you realize that building an app isn't just about making something work on your phone.
It's about making it work on someone else's phone too.
Building for Real Devices Changes Everything
One of the biggest lessons I've learned building Wumilo is:
You don't really know how your app behaves until other people use it.
An emulator can only tell you so much.
Your own phone can only tell you so much.
Automated tests can verify specific behavior.
But real users will find things you never expected.
Different manufacturers have different battery-management systems.
Different Android versions behave differently.
Different settings affect notifications.
Some devices aggressively optimize battery usage.
Others handle background work differently.
And sometimes someone sends you a message saying:
"The reminder didn't fire."
Now you're investigating Android alarms at midnight.
That's indie development.
You build something because you think you've covered everything.
Then someone with a completely different device shows you the thing you missed.
And honestly, that's one of the most useful parts of the process.
Small Feedback Can Change Big Things
One of my favorite parts of building Wumilo has been talking directly with users.
Because I'm an indie developer, feedback doesn't have to pass through a product manager, a support department, an analytics dashboard, and three meetings before reaching me.
Someone can simply tell me:
"I think this would be better if..."
And I can actually think about it.
Some of the improvements I'm working on come directly from these conversations.
Better snooze options.
Clearer reminder indicators.
Better recurring-task interactions.
Small changes to make certain screens feel less awkward.
None of these necessarily sound like huge features.
But when you're building an app used every day, those little details matter.
A product can technically work and still feel slightly annoying.
Those tiny moments of friction are often where the best improvements are hiding.
Why Android?
I chose to build Wumilo for Android partly because Android gives you a lot of room to build experiences that feel integrated with the phone.
Widgets.
Notifications.
Alarms.
Voice input.
Quick interactions.
Different screen sizes.
Different device configurations.
There's also a lot of complexity.
That's part of what makes it interesting.
I like the challenge of making an app feel like it belongs on the device rather than simply being a website placed inside an app.
A task manager is something you might open dozens of times.
It should feel fast.
It should feel familiar.
It should get out of your way.
I'm Building Wumilo as an Indie Developer
Wumilo isn't being built by a huge product team.
It's something I started because I wanted a task manager that worked the way I wanted.
That also means development isn't always perfectly predictable.
Sometimes I have a lot of time to work on it.
Sometimes I don't.
Sometimes an update takes longer than expected.
And sometimes a feature I really want has to wait.
One question helps me make those decisions:
Would this make the app better for someone who just wants to get things done?
Sometimes the answer is yes.
Sometimes the answer is:
"That's a cool feature, but it doesn't belong here."
And saying no to features can be much harder than building them.
Especially when you're the developer, designer, product manager, tester, and user all at the same time.
There Is Still a Lot to Improve
Wumilo is nowhere near finished.
I don't think a productivity app ever really is.
There are still things I want to improve around reminders, Focus Mode, widgets, recurring tasks, and the general experience of managing tasks throughout the day.
And I'm sure users will find things I haven't even thought about yet.
That's actually something I'm looking forward to.
When someone says:
"This part feels weird."
That's useful feedback.
It points to something that might not show up in analytics.
There is a big difference between an app that works and an app that feels good to use.
Usually, that difference isn't one giant feature.
It's dozens of tiny details.
The Bigger Idea
I didn't build Wumilo because I thought the world desperately needed another to-do app.
There are already plenty of them.
I built it because I think productivity software can sometimes forget what it's supposed to accomplish.
The goal isn't to build the perfect task-management system.
The goal isn't to have the most features.
The goal isn't to spend an hour organizing your productivity system every Sunday.
The goal is much simpler.
Remember what matters.
Decide what to do next.
And then actually do it.
That's what I'm trying to build with Wumilo.
Your tasks. Your focus. Your phone.
Top comments (0)