-
-
MySub — a simple way to track subscriptions and avoid unexpected charges.
-
The MySub app logo, representing multiple subscriptions managed in one place.
-
MySub development in Flutter and Dart using Visual Studio Code.
-
Desktop overview with monthly costs, upcoming payments, and subscription renewals.
-
Spending insights showing costs by category and billing cycle.
-
Settings page with themes, notifications, profiles, privacy, and local data storage.
-
Testing the responsive MySub interface on a real ZTE Android device.
-
Mobile renewals list showing subscriptions and their upcoming payment dates.
-
Renewal Center highlights payments that need attention in the next 30 days.
-
Mobile analytics showing billing cycles and the largest monthly subscription costs.
-
Mobile spending insights with monthly expenses, annual forecast, and active services.
-
MySub light theme displaying upcoming payments and average monthly spending.
-
Final project setup with Flutter code, Android testing, and the complete MySub repository published on GitHub.
Inspiration
The idea for MySub came from a problem I personally faced. I had several active subscriptions, including ChatGPT Plus, Spotify, cloud storage, educational platforms, and other online services. Sometimes I forgot when the next payment was due, how much I was spending in total, or whether I still needed a particular subscription.
I soon realized that this was not only my problem. Many of my friends, especially students, were dealing with the same situation. We regularly pay for AI tools, music, streaming platforms, cloud storage, design software, and learning services. Each subscription may seem affordable on its own, but together they can become a significant monthly expense.
Free trials make the problem even worse. People often sign up for a service, forget the cancellation date, and only notice the subscription after an unexpected charge.
Most existing solutions either require access to sensitive financial information, depend heavily on cloud services, or are more complicated than they need to be. I wanted to create something simpler and more privacy-friendly.
That is why I created MySub — a local-first subscription manager that gives users a clear view of their recurring expenses without requiring access to their bank account.
This is my first hackathon project, and I wanted to use it not only to build an application, but also to solve a real problem that affects me, my friends, and many other students.
What it does
MySub helps users understand and manage their recurring expenses from one place.
Users can:
- Add, edit, pause, and organize subscriptions
- Track prices, renewal dates, categories, and billing cycles
- View estimated monthly and yearly expenses
- See payments due during the next 30 days
- Review subscriptions that need immediate attention
- Compare spending across different categories
- Identify their largest monthly costs
- Track monthly, annual, and other billing plans
- Use separate local profiles with isolated subscription data
- Switch between responsive desktop and mobile layouts
- Use light, dark, or system themes
- Access safe cancellation guidance for services they no longer need
The application includes an Overview, a complete subscription list, a Renewal Center, spending insights, profile management, notification settings, and privacy controls.
Unlike solutions that require users to connect a bank account, MySub is designed around a local-first and privacy-first approach. Subscription and profile information stays on the user's device.
The main goal is not only to display numbers. MySub helps users notice forgotten subscriptions, prepare for upcoming payments, reduce unnecessary spending, and make more informed financial decisions.
How we built it
I built MySub using Flutter and Dart, allowing the project to support Android, desktop, web, and other platforms from a shared codebase.
For the interface, I used Flutter's Material Design components, reusable widgets, and responsive layouts. The desktop version uses a sidebar and wide dashboard layout, while the mobile version adapts the same features into compact cards, bottom navigation, and scrollable screens.
The application includes structured data models for:
- Subscription information
- User profiles
- Prices and currencies
- Categories
- Renewal dates
- Billing periods
- Notification preferences
- Application appearance and language settings
I implemented calculation logic that normalizes different billing cycles into estimated monthly and annual costs. This allows weekly, monthly, annual, and custom subscriptions to be compared in a consistent way.
MySub also calculates:
- Average monthly spending
- Annual spending forecasts
- Payments due during the next 30 days
- Spending by category
- Billing cycle distribution
- Largest recurring expenses
- Active and inactive subscription totals
The project follows a separated structure for the interface, models, application logic, services, integrations, and local data. This makes the code easier to maintain, test, and expand.
The current version stores data locally and supports isolated user profiles. It does not collect passwords, upload financial information, or require a cloud account.
For cancellation support, the app uses a secure external hand-off to official provider pages rather than trying to collect provider credentials.
I used Git and GitHub for version control and project publishing. I tested the responsive interface both on desktop and on a physical ZTE Android device, which helped me find and fix mobile layout problems that were not visible on a large screen.
Challenges we ran into
One of the biggest challenges was keeping the application useful without making it overwhelming. Subscription services can use different currencies, payment periods, prices, renewal conditions, and cancellation processes.
Another challenge was calculating recurring expenses accurately. A weekly subscription cannot simply be multiplied by four to calculate an average month, while yearly plans need to be represented correctly in both monthly and annual statistics.
Building one interface for very different screen sizes was also challenging. A dashboard that works well on desktop cannot simply be reduced in size for a mobile phone. I had to redesign navigation, cards, spacing, lists, and statistics so that the application remained usable on both platforms.
Privacy was another important challenge. Automatic subscription detection could require access to emails, banking information, or external accounts. Instead of requesting sensitive access in the current version, I chose a local-first design and began planning safer, permission-based approaches for future automation.
Cancellation is also more complex than opening one universal link. Every provider uses a different process, and some subscriptions are managed through external stores. I therefore focused on safe guidance and official provider hand-offs rather than claiming that every subscription can be cancelled automatically.
Accomplishments that we're proud of
I am proud that MySub grew from a personal problem into a complete working application with a clear purpose.
During the hackathon, I created:
- A working cross-platform Flutter application
- Responsive desktop and Android layouts
- A subscription management system
- A dedicated Renewal Center
- Monthly and annual spending calculations
- Category and billing-cycle analytics
- Multiple isolated local profiles
- Light, dark, and system themes
- Notification and reminder preferences
- Privacy-focused local data storage
- Safe cancellation guidance
- A public GitHub repository
- A working video demonstration
- Testing on a real Android device
I am especially proud that the project is not only a visual prototype. The screens are connected, the subscription data affects the calculations, and the application can be tested on a real device.
This is my first hackathon project, so completing a functional and polished cross-platform application was a major personal achievement. I had to learn new concepts, solve technical problems independently, and make product decisions under limited time.
I am also proud of the project's potential community impact. Students often have limited budgets but use many recurring digital services. Even a small forgotten subscription can matter. MySub gives them a free and understandable way to see where their money goes without handing over sensitive banking credentials.
What we learned
While working on MySub, I learned that building a useful application is not only about writing code. It requires understanding the user's problem, choosing the most valuable features, testing assumptions, and removing unnecessary complexity.
I improved my knowledge of:
- Flutter and Dart development
- Responsive interface design
- Cross-platform application development
- Reusable UI components
- Application architecture
- Local data management
- Recurring payment calculations
- Date and billing-cycle handling
- User profile isolation
- Privacy-focused product design
- Git and GitHub workflows
- Testing on physical Android hardware
- Product presentation and demo creation
Testing on a real phone taught me an especially important lesson: an interface that looks correct on desktop may behave very differently on a small screen. Some layouts had to be rebuilt rather than simply resized.
I also learned that automatic subscription detection and cancellation are more complex than they initially appear. These features involve privacy, security, provider-specific rules, account permissions, and third-party integrations.
Most importantly, I learned how to turn a problem I personally experienced into a real product with a clear audience, technical structure, and future direction.
What's next for MySub
The next step is to make MySub more automatic while preserving its privacy-first approach.
Planned features include:
- Reliable local payment reminders
- Free-trial expiration tracking
- Multiple currency conversion
- Historical spending charts
- Monthly budget limits
- Family and shared subscriptions
- Price-change alerts
- Duplicate subscription detection
- Export and backup options
- More languages and accessibility improvements
- A larger database of official cancellation instructions
I would also like to explore privacy-preserving subscription detection. Instead of uploading an entire inbox to a server, a future version could process selected receipts or subscription emails locally, with clear user permission.
Another planned feature is an AI assistant that could help users:
- Understand their subscription spending
- Detect unusual or unnecessary expenses
- Compare cheaper alternatives
- Prepare for upcoming renewals
- Find official cancellation instructions
- Build a realistic subscription budget
The long-term goal is to make MySub a complete, accessible, and privacy-friendly subscription management assistant for students and everyday users.
MySub is designed around a simple idea: people should be able to understand and control their recurring expenses without giving another company access to their entire financial life.
Log in or sign up for Devpost to join the conversation.