How we built OneLimit: a developer-dad's side project

Every side project starts with a problem you can't stop thinking about. For OneLimit, the problem was this: my kids had daily screen time limits. They were following them. And they were still on screens way more than I wanted.

It took me an embarrassingly long time to figure out why. They had 90 minutes on the Switch. An hour on the PS5. An hour and a half on the iPhone. Another hour on the Xbox. And time on the Windows PC too. Five separate limits, five separate systems - all configured, all enforced, all working exactly as designed. The total was way more than I intended. I had set that up. I just hadn't done the addition.

That was the moment OneLimit started as an idea. It took another year to become an app.

The thing I kept searching for that didn't exist

My first instinct was that someone must have already solved this. I'm a developer - I know how to search. I spent a few evenings looking for an app that would let me set one daily screen time limit across multiple devices and platforms. I found a lot of single-platform tools. I found monitoring apps that gave you reports but didn't enforce anything. I found some hardware solutions that were overkill for our situation.

What I couldn't find was something simple: one number, all screens, enforced automatically. It seemed like an obvious thing to want. It didn't exist.

So I started thinking about whether I could build it.

What made this technically hard

The first thing I had to understand was why nobody had built this yet. The answer: each platform gates its parental control data behind its own APIs, with its own authentication model and its own set of restrictions on what third-party apps can do.

Apple's ScreenTimeKit is the most powerful but also the most restrictive. It's a first-party framework that gives apps legitimate, OS-level screen time management capabilities. To use it, your app has to be set up with the right entitlements, and those entitlements aren't handed out automatically - Apple reviews what you're doing with them. The enforcement is real: it runs at the OS level and is meaningfully hard to bypass.

PlayStation Family Management exposes an API through PlayStation Network that lets authorized apps read playtime data and manage family accounts. Sony has built this primarily for their own app, but the API is accessible. The challenge is building a reliable, polled integration that keeps data in sync without hammering the endpoint.

Nintendo Switch Online similarly exposes account and parental control data through an API that the official Parental Controls app uses. Reverse-engineering how this works (legally, by observing traffic from the official app) was one of the more interesting problems to solve.

Microsoft Family Safety provides an API for managing Xbox and Windows PC screen time. Of all the console integrations, Microsoft's is the most structured - it's a documented API with proper OAuth, and it covers both Xbox consoles and Windows PCs through the same account.

None of these APIs were designed to talk to each other. They use different authentication flows, different data formats, different rate limits. Building OneLimit meant being the bridge between them - pulling time data from each, maintaining a unified budget state, and propagating enforcement actions back to each platform.

The parts that surprised me

I expected the API work to be hard. I didn't expect the UX to be harder.

The technical integration is genuinely complex, but once it works, it works. The interface - how you actually communicate "you have 45 minutes left, across all your devices" to a 9-year-old in a way that feels fair and understandable - that took a lot more iteration than I anticipated.

Early versions of the app were too technical. Too many numbers, too much detail. My kids would look at it and shrug. The version that actually changed behavior was much simpler: a budget ring on the child app that shows remaining time as a visual countdown. Green means plenty. Yellow means getting close. Red means almost gone. That's it. Kids understand that instantly.

The other surprise was how much the enforcement moment mattered. When time runs out, what happens? And how does the kid find out before it runs out? Getting those transitions right - warning with enough time to actually wrap up, locking gracefully, giving a clear explanation - that's where a lot of the design work went.

Features that came from real parenting situations

Ask for More Time came from a specific negotiation: "Can I have more time?" Instead of that being an ad-hoc parent decision every time, OneLimit lets kids send a request right from their device. The parent approves or denies with a single tap. It removes the argument from the room.

Streaks came from wanting to make self-regulation feel rewarding. Kids who stay within their daily budget build a streak. It's a simple incentive, but it turns the limit from something imposed into something earned.

Emergency lock came from a situation I suspect a lot of parents know: the moment when a kid is spiraling over losing at a game and every additional minute of screen time is making it worse. Being able to instantly lock all devices from my phone - without having to physically intervene and take something away - turned out to be genuinely useful.

Bedtime countdown gives kids a clear, visible wind-down period before screens lock for the night. No sudden cutoff - they see the time approaching and can wrap up naturally.

Schedules came from the school-day versus weekend reality. The right limit on a Tuesday is different from the right limit on a Saturday. OneLimit lets you set different budgets for different days, so weekends can have more breathing room without that becoming the default.

What we got wrong (and fixed)

The first version tried to do too much. Device usage analytics, detailed breakdowns by app, trend reports over time. All of that is interesting data, but it's not what most parents actually need in the moment. What parents need is: how much time is left, and is it going to be a problem tonight? Everything else is noise.

We stripped a lot of that back. The current app is simpler than early versions. That was the right call.

We also initially made it too hard to grant occasional extra time. The system was rigid in a way that felt punishing - to the kid and to us. Real life isn't rigid. Some days deserve more flexibility. Building in easy, one-day exceptions (without dismantling the overall structure) was important.

Where OneLimit is now

OneLimit is a real app in the App Store. It supports iPhone, PS5, Nintendo Switch, Xbox, and Windows PC. There's a free tier that covers one child and one device - enough to try it and see if the core idea works for your family. The Pro plan removes the limits - current pricing is shown in the App Store.

It's still a small operation. We're a tiny team building something we personally needed, for a problem we think a lot of families share. The tagline - "One budget. All screens." - is genuinely what we set out to build, and it's what the app does.

If you're a parent managing multiple devices and feeling the friction of per-device limits, we'd love for you to try it. And if you have feedback - things that aren't working, features you'd find useful, ways we got something wrong - we actually read it and it actually shapes what we build next.

That part of being a small team isn't so bad.

OneLimit is available on iOS with support for iPhone, PS5, Nintendo Switch, Xbox, and Windows PC. Get started at onelimit.app.