How I Built a 4MB iOS App Blocker to Stop Doomscrolling

The story of how fighting dopamine loops led to building Scroll Brake, why popular competitors demand suspicious permissions, and how to conquer hidden traps in Apple's Screen Time APIs.

Why I Needed an App Blocker in the First Place

I am obsessive about personal productivity. Over the years, I've developed my own system for managing time and daily energy that keeps my schedule structured and gets hard engineering projects shipped.

Yet there are moments when you just pick up your phone on autopilot and start doomscrolling Reels. One short video, a second, a third: the algorithm serves up an endless stream of engaging clips. You thought you were taking a two-minute breather, and suddenly 40 minutes or a full hour has evaporated. Social media algorithms are designed by top engineers to capture human attention at any cost. Each swipe feels slightly more rewarding than the last, trapping your brain in an infinite dopamine loop.

I had zero intention of writing my own app. As a software engineer and founder, my time is scarce, and I prefer using proven off-the-shelf tools. So I went straight to the App Store.

What's Broken with Modern App Blockers

I tested the category leaders: Opal, OneSec, ScreenZen, Refocus, alongside Apple's built-in Screen Time. Almost immediately, I ran into architectural and design patterns that left me bewildered:

The Notification and Privacy Paradox

The very first thing almost all these apps do is ask for push notification and analytics permissions. Why would a tool designed to keep me off my phone need to wake up my display with notifications? As it turned out later while building the app, this wasn't greed: it was an old system constraint in iOS that I'll break down below in the technical section.

Aggressive Paywall Walls

Before you even see the main interface or verify whether the tool solves your problem, you get hit with an aggressive subscription screen. It comes wrapped in a "free trial" clearly designed around the hope that users forget to cancel. As an entrepreneur, I understand the conversion math; as a user, I dislike dark patterns.

The Ineffectiveness of Apple's Default Screen Time

Apple's native Screen Time fails on human psychology. When the standard system overlay pops up, your thumb reflexively taps "Ignore Limit for 15 minutes". There is zero cognitive friction: the action happens entirely on muscle memory.

I had no desire to audit dozens of clones with identical paywalls. I realized building a lightweight, native tool for myself would be both faster and more honest.

Scroll Brake Principles: 4MB, No Trackers, No Subscriptions

At NovaSynapse, we follow the principle “Everything you need. Nothing you don’t.” Software should solve the problem, conserve battery, and respect user boundaries.

That's how Scroll Brake was born:

• ~4 MB install size: No bloated cross-platform runtimes, no web views, zero third-party tracking SDKs.
• 100% Privacy-First: Zero accounts, local-only storage, and zero remote servers. Everything executes locally on-device using native iOS APIs.
• Cognitive friction over brute-force bans: To extend time in social apps, you must engage your prefrontal cortex: by solving a quick math puzzle. That single second of friction shatters autopilot.
• Anti-dopamine UX over gamification: After solving the puzzle correctly, I deliberately don't show confetti, fireworks, or congratulatory messages. Feeding the brain cheap dopamine for unlocking social media is absurd. The screen is intentionally kept as boring and quiet as possible: the timer is unlocked, and returning relies on the standard iOS back breadcrumb in the top-left corner (by design, iOS privacy protects which specific app triggered the shield, so the host app cannot auto-redirect you).
• Monetization: Up to 3 rules are completely free (I only use one myself: the "Social Networks" category capped at 5 minutes a day). For anyone needing more rules, I added a one-time Lifetime purchase instead of forced subscriptions.

The 4-Day Build Story: AI & Xcode Tools

I built the app with AI using Antigravity and Gemini models (3.1 Pro and Flash).

I've tinkered with mobile development before: building with Flutter and exploring native iOS: but that was before AI coding assistants became widespread. With AI, assembling a focused, lightweight app moved remarkably fast. You still can't just blindly accept generated code: Apple's system extensions are notoriously brittle, so I reviewed every line myself to prevent crashes and memory leaks. But overall, the build went smoothly, taking just 3–4 working days including manual testing on physical devices and older iOS versions:

• Icon in 15 minutes: Instead of manually exporting dozens of PNG layers, I used Xcode's Icon Composer developer tool. Vector layers automatically adapt to light, dark, and tinted iOS themes.
• App Store Review in < 24 hours: Because the app has zero tracking SDKs and requests no private user data, Apple approved the build for the App Store the very next day.

Engineering Deep-Dive: Hidden Traps in Apple's Screen Time API

Now for the technical meat: working with the trio of ManagedSettings, DeviceActivity, and FamilyControls. If you build an app using Apple's Screen Time API, you will inevitably hit three architectural walls. Here is how I solved them:

Why Competitors Demand Push Notifications (iOS < 26.5 vs iOS 26.5+)

Users frequently complain about app blockers spamming notifications, but developers were long trapped by Apple's extension sandbox.

• The Legacy Constraint:

When an app is blocked, the system displays the protective overlay: ShieldActionExtension. The user taps an action button like "Extend". But this extension runs in a restricted sandbox where calling UIApplication.shared.open is strictly forbidden at both the compiler and system level. The ShieldActionResponse enum historically only supported .close, .defer, and .none. It was impossible to open the host app directly to present a code or puzzle!

• The Industry Hack:

The only workaround was firing a local push notification (UNUserNotificationCenter). The user had to pull down Notification Center or tap the banner to open the app. That is precisely why almost every competing blocker requests notification permissions.

• My Native Fix in iOS 26.5+:

Apple finally added the native response case ShieldActionResponse.openParentalControlsApp. When returned, the system immediately launches the main host app directly to the math puzzle view (MathPuzzleView):

  // ShieldActionExtension.swift
  defaults?.set(true, forKey: "launchedFromShieldAction")
  completionHandler(.openParentalControlsApp)

By targeting iOS 26.5+ as the deployment baseline (IPHONEOS_DEPLOYMENT_TARGET = 26.5), I eliminated push notification hacks entirely.

The Sandbox Ban on Direct Usage Analytics

I frequently get asked: "Why doesn't the app show minute-by-minute app charts in custom analytics?"

The answer: Apple architecturally isolates Screen Time data from the host app.

• Access to the DeviceActivityResults array is granted exclusively to DeviceActivityReportExtension, which runs in an isolated system process.
• The host app embeds only a visual container view, DeviceActivityReport. It renders out-of-process and projects the rendered view into your app's UI.
• Data never leaves the extension sandbox: host apps cannot write this data to SQLite, serialize it into arrays, or transmit it over the network.

Apple's documentation is explicit:

"To protect user privacy, the DeviceActivityReport extension runs in a sandbox, and its data doesn’t leave the extension. Instead, the extension creates and returns views that your app displays."

• Impact on Monitoring:

Tracking limits through DeviceActivityCenter works strictly on a threshold subscription model (DeviceActivityEvent.threshold). The system notifies DeviceActivityMonitorExtension only when the threshold is reached (eventDidReachThreshold), without streaming any intermediate usage telemetry.

• Why You Return via the Top-Left Breadcrumb:

In iOS, host apps have zero access to the bundleIdentifier that triggered the shield. As a result, an app cannot programmatically jump the user back into Instagram or TikTok. You simply tap the system back breadcrumb in the top-left corner of the status bar.

Overcoming Hidden Screen Time API Bugs

During stress testing, I encountered subtle iOS platform bugs that can break any blocker:

Event Caching Bug in DeviceActivityCenter

• The Bug: When updating the threshold for an existing DeviceActivityName (during an extension), iOS would fail to trigger on the new threshold.
• The Fix: Generate a unique activity name containing a session token DeviceActivityName("limit__") preceded by an explicit stopMonitoring() call.
• Apple Documentation: DeviceActivityCenter.startMonitoring.

deviceActivityCenter.stopMonitoring([previousActivityName])
let newActivity = DeviceActivityName("limit_\(UUID().uuidString)_\(sessionToken)")
try deviceActivityCenter.startMonitoring(newActivity, during: schedule, events: events)

The Next-Day Reset Glitch (Dual-Event Schedule Pattern)

• The Bug: If a DeviceActivitySchedule was configured with repeats: true and a user extended their time by 1 minute, the system would apply that same 1-minute threshold the following morning instead of resetting to the full daily limit.
• The Fix: Register two distinct events in a single schedule:

• mainEvent: the standard full daily limit for tomorrow.
• extEvent: a temporary event with the current date embedded in its identifier, expiring at 23:59 tonight.

OOM Crashes (Code 11) in DeviceActivityReport

• The Bug: Placing reactive timers (e.g. ticking second counters in SwiftUI) anywhere near a DeviceActivityReport hierarchy triggered continuous XPC re-evaluations of 7-day usage logs. This caused rapid memory leaks and an instant process termination by iOS with an Out-Of-Memory (OOM) code 11 error.
• The Fix: Completely eliminate reactive timers in UI views displaying reports, lock report filter parameters without constant mutations, and refresh data strictly on lifecycle events (onAppear, willEnterForeground).

How I Configured It for Myself

Since launch, Scroll Brake has become my primary defense against fragmented attention.

My personal configuration:

• 1 Rule: "Social Networks" category blocked.
• Base Limit: 5 minutes per day.
• Extension: 5 minutes granted per solved math puzzle.
• Hard Stop: Maximum 5 extensions per day.

I physically cannot spend more than 25 minutes a day inside social apps. More importantly, my brain knows: watching a shared video requires mental friction. That tiny barrier is enough, 8 times out of 10, to set the phone face-down and get back to real work.

UPD (October 2026): Strict Mode, Adaptive Calibration, and Bringing Friction to Chrome

Since publishing this article, Scroll Brake has received several major updates, and I renamed the app on the App Store to make its core purpose unmistakable: Scroll Brake: Math App Blocker.

The concept has thoroughly proven itself: a brief mental math challenge remains the quietest, most natural, and universal way to interrupt subconscious habit loops. Unlike apps requiring you to do squats in front of a camera, scan a barcode on a coffee bag, or endure blaring alarms, mental arithmetic takes 5–15 seconds and works anywhere without drawing attention: on crowded transit, in silent meetings, or in bed before sleep.

Here are the key takeaways and new capabilities built from real-world daily use:

Apple App Store Review: From 24 Hours to 3 Hours

Perhaps the most pleasant surprise: while the initial release took nearly 24 hours to clear review, subsequent version updates now get approved by Apple remarkably fast: the latest update passed inspection in just 3 hours. Zero third-party ad SDKs, zero telemetry, and strictly following Apple Guidelines pays off.

Strict Mode: When the Brain Learns to Calculate on Autopilot

Daily use revealed an interesting behavioral quirk: during moments of deep fatigue or stress, dopamine cravings can be powerful enough that the brain adapts to solve 3–4 math problems in a row just to get to the feed. To close this loophole, I added Strict Mode:

• Daily Unlock Cap: Set an unyielding limit on extensions (e.g. no more than 4–5 unlocks per day).
• Session Intervals Over a Single Bulk Hour: Instead of one continuous hour-long allowance, it is far more effective to split usage into 10-minute sessions. Every 10 minutes, the shield reappears to snap conscious attention back into focus.
• Locked Until Midnight: Once your daily unlock quota runs out, the shield stays firmly locked until 00:00 tomorrow. No amount of correctly solved math equations will unlock the app.
• No Weekend Exceptions: I intentionally avoided day-of-week scheduling. Dopamine habits do not respect a work calendar: binging on infinite feeds all weekend instantly unravels the discipline built throughout the week.

Automatic Difficulty Calibration at First Launch

To ensure math barriers never feel frustrating or out of reach, I introduced a seamless 1-minute calibration test during onboarding: 3 warm-up questions automatically determine your comfortable baseline (from single-step arithmetic to mental multiplication of two-digit numbers). The algorithm is also adaptive: if you are tired in the evening and make a mistake, difficulty softens automatically; if you solve problems effortlessly in seconds, it gradually scales up to keep focus sharp.

Expanding to Desktop: Official Chrome Extension

Once mindless scrolling disappeared on my iPhone, the habit immediately tried migrating to my laptop: while writing code or documentation, my hands would unconsciously open a new tab and type reddit.com, x.com, or youtube.com.

To eliminate this vulnerability across devices, at NovaSynapse we launched the official Scroll Brake for Chrome extension (compatible with all Chromium browsers: Brave, Microsoft Edge, Opera, and Vivaldi):

• Manifest V3 & Pure Vanilla JS: Ultra-lightweight, zero bloated frameworks, and virtually no impact on CPU or battery.
• 100% Privacy & Zero Sync: Zero user accounts or cloud databases. All rules and counters remain strictly inside local chrome.storage, allowing you to keep completely isolated configurations for work vs. personal browser profiles.
• True Active-Time Tracking: Unlike blockers where timers tick away passively in background tabs, Scroll Brake only deducts time when you actively interact with the page (scrolling, moving the mouse, typing). Switch tabs or minimize the browser, and the countdown pauses instantly.
• Surgical URL Blocking: Block entire domains or surgically target addictive feeds like youtube.com/shorts* while keeping educational lectures, tutorials, and technical docs fully accessible.

My Current Daily Configuration

Today, this combination protects my attention across both devices:

• On iPhone: "Social Networks" category locked (5-minute base allowance + 5-minute extensions, capped at 4 unlocks in Strict Mode: maximum 25 minutes daily).
• In Chrome: Reddit, X, and YouTube Shorts shielded with identical mental friction and active-time tracking.

That brief mental pause continues to be enough, 9 times out of 10, to simply close the tab, put the phone down, and get back to what genuinely matters.