Skip to content
Mai Trinh
On holdPaused — interview-question dataset pending

Personal Hub

My personal Android assistant app — Tasks, Goals, Notes, and a spaced-repetition Learning engine, built by applying my reusable Android product foundation. Currently on hold while I finish the interview-question dataset the next Learning stage depends on.

Role
Solo developer — product, architecture & Android implementation
Platform
Android

Project overview

Domain
A personal Android assistant — consolidating my own tasks, goals, notes, and spaced-repetition learning (including, once its content is ready, technical interview preparation) into one private app, built on my reusable Android product foundation.
Product
Personal Hub is my own personal Android assistant application — not my professional portfolio, and not a portfolio-management tool. It brings together Tasks with due-date reminders, period-based Goals, a quick-capture Notes inbox, and a spaced-repetition Learning engine (for English/Chinese vocabulary today, and technical interview preparation once that content exists), all built by applying the same reusable Android product foundation I maintain across my personal apps. The broader direction is to keep centralizing useful parts of my own workflow into this one private app over time.
Audience
Built for my own daily use — planning my tasks and goals, capturing notes without friction, and reviewing spaced-repetition flashcards, with technical interview preparation as the next thing the Learning engine is meant to support once its content is ready.
Why it exists
I wanted one private assistant app for the parts of my own workflow that were scattered across separate tools, and I wanted to build a real, working consumer application on top of the reusable Android foundation I maintain — not just a template project, but something that actually ships features I use myself.
Problem
Centralizing my own day-to-day tasks, goals, notes, and ongoing learning/review into one app I control, instead of juggling several unrelated tools — with the Learning engine's next step being to extend that same spaced-repetition foundation to technical interview preparation, once its content is ready.

My role & contributions

A personal, solo project — product idea, architecture, and Android implementation are all my own work, built by applying my reusable Android product foundation to a real consumer application. What's implemented and tested today: Tasks (with due-date reminders via a pure eligibility-decision function), period-based Goals, a Notes quick-capture inbox, and the Learning engine's spaced-repetition scheduler, covered by unit tests and a passing on-device instrumented test run. An AiJob data model exists in the local database as a foundation for a possible future feature, but it isn't wired into any repository or screen yet — that part is not user-facing functionality today.

Challenges & solutions

  1. Technical challenges

    The next stage of the Learning engine — technical interview preparation — depends on a structured interview-question JSON dataset that I haven't finished preparing yet. That's a content dependency, not an architecture problem: the scheduling engine, local data model, and Learning screens the feature would run on are already built and tested; what's missing is the actual question-bank content. Beyond that, the same two problems recurred across the rest of the app: keeping a Task's optional link to a Goal safe without a database foreign key, and making "should this task remind me right now" a single, testable rule rather than logic scattered across whatever triggers a task change.

    How I approached it

    Reminder eligibility is a single pure function that takes a task's current state and returns whether a reminder should exist right now — every code path that could change that answer calls the same function, so there is exactly one place that rule lives. The Goal/Task relationship is a deliberate soft reference: deleting a Goal clears the association on its Tasks first and only then removes the Goal itself, so a crash between those two steps can never leave an orphaned reference, without needing a database transaction for safety. The Learning engine's review scheduling is a small, self-contained spaced-repetition algorithm operating on plain data, kept separate from the repository and UI layers so it can be tested directly and reused for a new content category — like interview questions — once that content exists, without changing the scheduling logic itself.

Architecture & technologies

A native Android app in Kotlin with Jetpack Compose, Hilt for dependency injection, and Room for fully local, offline persistence — there is no backend and no network permission of any kind. It's built by applying a deliberately minimal, bootstrap-only set of modules (design system, local storage, dependency injection setup, notification scheduling) from the same reusable Android product foundation I maintain across my personal apps, adding only what each feature actually needs rather than pulling in the foundation's full capability set.

Technologies

  • Kotlin
  • Jetpack Compose
  • Hilt
  • Room
  • Kotlin Coroutines
  • Kotlin Serialization
  • AndroidX Navigation Compose
  • WorkManager
  • JUnit

This project demonstrates

This shows that my reusable Android foundation isn't just an abstract template — it can be applied to build a real, working personal application with tested functionality. It also demonstrates being explicit about the difference between an implemented engine (the spaced-repetition scheduler) and the content that engine needs for a specific purpose (the interview-question dataset): the project is honestly on hold for that named content dependency, not stuck on an architecture decision or abandoned.

  • Android Development
  • Offline Support
  • QA & Testing

Current progress

The core Tasks/Goals/Notes/Learning-foundation functionality is implemented and tested; development is paused specifically because the interview-question JSON dataset the next Learning/interview-preparation stage depends on hasn't been finished yet.

  1. Product definition

    Done
  2. Core development

    Done
  3. Interview dataset

    In progress

Have a similar project in mind?

Tell me about your product or challenge, and we can discuss how I can help.

Work With Me