I built a study timer app for Android entirely from my phone (and the first build failed with 30 errors)

I wanted a study timer that felt like a serious workstation, not a reskinned stopwatch. So I built one: Fieldnote, a free and open-source study command center for Android phones and tablets.

The twist: I wrote and shipped the whole thing from my phone. Termux for git, GitHub Actions for builds, and AI assistants for the heavy typing.

Repo: https://github.com/nandandas2407-web/fieldnote
Download the APK: https://github.com/nandandas2407-web/fieldnote/releases/latest

The idea

Apps like YPT are popular with students because they make studying visible: live timers, streaks, charts. But I wanted something that:

• works fully offline, with no account
• keeps your data on your device
• looks good on a tablet, not just a stretched phone screen
• calculates every chart from real sessions, never from fake data

What it does

• Focus timer: stopwatch and Pomodoro, subjects, break tracking, session notes
• Planner: day, week and month views, priorities, repeating tasks, exam countdowns
• Analytics: calendar heatmap, subject donut charts, weekly stacked bars, 12-week trend, start/end regularity, streaks, CSV export
• Focus protection: pick allowed apps and get alerted when you open anything else mid-session
• Library: notes with a stylus or finger sketch pad
• Adaptive layout: sidebar on tablets, bottom navigation on phones

The design: four colours, nothing else

I started from a four-colour forest palette:

Every other shade is a blend or opacity of those four. Thin 1px borders instead of shadows, 4dp corners instead of pills, serif headings with monospaced numerals. The goal was "editorial dashboard", not "generic SaaS template".

The three parts that were actually interesting

1. A timer that survives everything

My first instinct was a counter that ticks up every second. That breaks the moment Android kills your process.

Instead, the timer stores timestamps: when the session started, when it was last resumed, and how much focus time was banked before that. Elapsed time is always recomputed:

fun focusNow(now: Long): Long = focusMs + if (running) (now - resumedAt) else 0L 

Kill the app, reboot the UI, come back an hour later: the number is still right. A foreground service keeps the process alive and shows a live chronometer notification.

2. Stats from sessions, not from state

Every chart reads from one sessions table. Streaks, heatmaps, donuts and regularity plots are pure functions over that list. Because they are pure, they are easy to trust and easy to test.

3. Detecting distractions honestly

Focus protection uses Android's Usage Access API to see which app is in the foreground. If it isn't on your allowed list, you get an alert and a distraction is counted.

It does not force-close other apps. Android only allows that through accessibility or device-admin permissions, and I didn't want to ask for those. I'd rather ship an honest feature than a scary one.

Building an Android app from a phone

My whole pipeline:

1. Write the code, with AI help.
2. Push from Termux with git and the gh CLI.
3. A GitHub Actions workflow builds the APK.
4. gh run download drops the APK into my Downloads folder.

No laptop, no Android Studio.

The first build failed with ~30 errors

I couldn't compile the project where it was written, so the very first CI run was also the first compile. It failed. Loudly.

Almost every error came from two mistakes:

• A missing import. rememberSaveable lives in androidx.compose.runtime.saveable, and a wildcard import of runtime.* does not include it. One missing line, five files, a wall of red.
• A trailing-lambda trap. I declared a composable as MonthHeat(month, byDay, selected, onSelect, modifier). In Kotlin, a trailing lambda binds to the last parameter, so my { ... } was being handed to modifier. The fix was to move onSelect to the end.

Lesson: in Kotlin, put the callback you want as a trailing lambda last.

What it can't do (yet)

I'd rather say this up front:

• No study groups or global rankings. Those need a server. The app only checks that a server URL is reachable, and the planned API is documented in the repo.
• No forced app blocking, widgets, Wear OS app or cloud backup.
• It currently ships as a debug-signed APK, not a Play Store build.

A note on AI

I'm being transparent here: I planned the feature list and design direction with ChatGPT, and the code was written with help from Claude. I then pushed, built, debugged and shipped it myself. AI wrote a lot of the keystrokes, but the compile errors still needed a human to read the logs and push the fix.

Try it, break it, improve it

• Install the APK from the Releases page
• Open an issue if something breaks
• PRs are welcome. Good first ideas: a light theme, backup/restore to a file, home-screen widgets

If you've built something similar, or you have opinions on Compose chart libraries versus custom Canvas charts, I'd love to hear in the comments.

If this helped, a star on the repo goes a long way.