BOOH: The 3 AM App I Wish Every New Parent Had

Abhishek Kumar — Sun, 04 Oct 2026 20:13:55 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

There is a special kind of tiredness that only exists at 3 AM.

You're awake.
The baby just fell asleep.
You finally put your phone down.

And then the question appears:

“How long do I have before the next wake-up?”

I built BOOH around that question.

BOOH is a privacy-conscious nighttime dashboard designed for a new parent who doesn't need another complicated parenting app. They need one simple answer:

“How much sleep time do I probably have?”

Instead of showing endless charts and statistics, BOOH looks at the baby's previous sleep, feeding, and wake patterns and estimates:

expected sleep duration
probability of waking within the next 60 minutes
the usual sleep duration from the recent baseline
a short, calm explanation of the prediction
an optional voice version for those moments when even reading feels like too much work

The idea came from thinking about a friend who was going through the exhausting reality of caring for a newborn.

I didn't want to build another generic AI chatbot.

I wanted to build something that could be useful when someone is too tired to use an app.

That's BOOH.

Demo

🚧 Live Demo: Coming soon

🎥 Video Demo: Coming soon

The final demo will show the complete journey:

Login
  ↓
Choose Baby
  ↓
Import Sleep History
  ↓
Analyze Pattern
  ↓
Get Prediction
  ↓
See "How Long Do I Have?"
  ↓
Listen to the Summary

Code

The project is open source because I want people to be able to understand exactly how the prediction is being made and what happens to their data.

GitHub: BOOH Repository

The project is being built with a strong separation between:

User Data
     ↓
Feature Engineering
     ↓
Prediction Model
     ↓
Prediction
     ↓
AI Summary

The language model is deliberately not responsible for making the numerical prediction.

That distinction matters.

How I Built It

The interesting part of BOOH isn't simply that it uses AI.

It's how the AI is used.

The architecture combines several open-source technologies:

🧠 TabPFN — Prediction

BOOH uses TabPFN for the numerical prediction layer.

The model works with structured features extracted from the baby's history, such as:

recent sleep duration
time since the last feed
recent wake intervals
rolling sleep totals
time of day
day/night patterns
recent event counts

Alongside TabPFN, BOOH keeps a simple last-7-day baseline.

This gives us something important:

AI prediction vs. a simple baseline.

I don't want the app to say:

“AI says 47 minutes.”

and expect everyone to trust it.

I want to know whether the model is actually doing better than something simple.

So BOOH evaluates the prediction using metrics such as MAE and Brier score on held-out recent data.

🤖 Gemma — Explanation, Not Prediction

The language model has a very specific job.

It doesn't decide when the baby will wake up.

It receives structured prediction results and turns them into a short, human-friendly explanation.

For example:

“You may have around 45 minutes before the next wake-up. The recent pattern suggests a moderate chance of waking within the next hour.”

The model is restricted to short summaries.

It doesn't receive the entire baby history unnecessarily.

It isn't allowed to diagnose medical conditions, recommend medication, or invent information.

If the model fails, BOOH falls back to a deterministic summary.

🔊 ElevenLabs — When Reading Is Too Much

At 3 AM, even reading a screen can feel like work.

So BOOH can turn the summary into a short audio message.

The voice layer is optional and can be disabled completely for offline development.

The frontend never receives the ElevenLabs API key.

📊 Huckleberry Import

BOOH can import existing baby-tracking data through a CSV workflow.

Instead of scraping or depending on a private service, the importer converts the exported data into BOOH's own normalized event format.

That means the system can work with:

Sleep
Feed
Wake

rather than tying the prediction engine directly to one application's internal format.

🐳 Production Architecture

The application is designed as a real full-stack system rather than a notebook demo.

Next.js
   ↓
FastAPI
   ↓
PostgreSQL
   ↓
Feature Engineering
   ↓
TabPFN
   ↓
Prediction
   ↓
Gemma
   ↓
ElevenLabs

Authentication uses Google OAuth.

The application is containerized with Docker and designed for deployment on Render.

Privacy Was a Design Requirement

Baby data is sensitive.

So one of my rules while building BOOH was:

Just because AI can see something doesn't mean AI should see it.

The numerical prediction operates on structured features.

Gemma does not need the baby's entire sleep history.

The system also enforces ownership checks so one authenticated user cannot access another user's baby data.

Secrets such as:

OAuth credentials
database credentials
AI API keys
TTS credentials

are never supposed to be committed to Git.

Security checks are part of the development workflow rather than something I want to remember at the end.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

I could have built BOOH as:

Baby data
   ↓
Send everything to a closed AI API
   ↓
"AI prediction"

That would have been much easier.

But it would also make it harder to understand what is happening to the data and harder to experiment with the actual prediction system.

Open innovation gives me the ability to separate the problem into pieces.

I can choose:

TabPFN for structured prediction.

Gemma for language generation.

FastAPI for the backend.

PostgreSQL for persistence.

Next.js for the interface.

And potentially replace any individual component later.

That is powerful.

If a better open model appears tomorrow, I don't have to rebuild BOOH from scratch.

I can swap the model.

If I want to run inference locally, I can.

If I want researchers or developers to inspect the feature engineering, they can.

If I discover that the model isn't better than the baseline, I can show that too.

That's what I like about open innovation:

the system becomes something people can inspect, question, improve, and replace.

For a project dealing with something as personal as a baby's routine, that transparency matters even more.

My Agent Session

BOOH is also an experiment in AI-assisted software engineering.

I'm building the project using multiple coding agents with an orchestration and loop-engineering workflow.

Instead of asking one AI agent:

“Build the entire application.”

I'm breaking the project into independent engineering tasks.

For example:

                    BOOH Orchestrator
                           │
        ┌──────────────────┼──────────────────┐
        ↓                  ↓                  ↓
     Backend            Frontend             ML
        ↓                  ↓                  ↓
      Data                LLM              DevOps
        └──────────────────┬──────────────────┘
                           ↓
                       Integration
                           ↓
                        Security
                           ↓
                           QA

Each agent has a defined responsibility.

The development loop is:

PLAN
 ↓
IMPLEMENT
 ↓
TEST
 ↓
SECURITY REVIEW
 ↓
REVIEW DIFF
 ↓
UPDATE CONTEXT
 ↓
COMMIT
 ↓
INTEGRATE

I also keep a persistent CONTEXT.md so that when I return to the project in a new AI session, the next agent doesn't have to rediscover the entire project.

Every logical task gets its own Git commit.

That makes the AI-assisted development process much easier to inspect and recover.

The Part I'm Most Proud Of

BOOH isn't trying to predict everything about a baby.

It's trying to answer one small question at an incredibly difficult moment.

You don't need a giant dashboard at 3:00 AM.

You don't need 15 graphs.

You don't need an AI that talks for five minutes.

You need:

“You probably have about 45 minutes.”

And maybe, if you're lucky:

45 minutes of sleep.

That's BOOH.

Prize Categories

I'm entering BOOH for the partner categories that fit the technologies used in the project.

Open-source AI / open innovation
AI / agentic development
Developer tooling / open-source software
[Add applicable partner category here]

What's Next?

The current goal is to take BOOH from a hackathon prototype into something that could actually be useful.

Next steps include:

improving prediction quality
collecting better evaluation data
expanding manual event logging
improving the nighttime UX
local/offline inference options
better model comparison
stronger privacy controls
production deployment
making the project easier for contributors to understand

Because ultimately, I don't want BOOH to be something I built once for a weekend.

I want it to become something that another tired parent can open at 3 AM and immediately understand.

“Okay. I probably have 45 minutes.”

Now go get some sleep. 🌙

DEV Community: Abhishek Kumar