Blog
Engineering Notes
Build notes, architecture decisions, and the occasional hard-won lesson from shipping native iOS, Android, and server-side Swift.
All articles
- SwiftUIFeatured
Where Handoff Actually Arrives on iOS and macOS
Part 3 of our Apple Continuity series. On iOS, a scene-adopted app receives Handoff in scene(_:continue:) and never in the app delegate. The three app-delegate Handoff methods carry an availability upper bound of 26.0; the scene and AppKit equivalents carry none. With the fetch technique behind those figures, the three-callback set, and a snippet that proves which seam fires in your app.
Ben Van Aken10 min read - SwiftUI
Your First NSUserActivity: Handoff in Swift
Part 2 of our Apple Continuity series: the smallest Handoff that works end to end. Build the activity, declare NSUserActivityTypes in every receiving target, advertise and receive it in SwiftUI. The same Team ID plus a declared type is the entire gate.
Ben Van Aken8 min read - SwiftUIFeatured
Apple Continuity Is Three Different Contracts
Part 1 of our Apple Continuity series. Continuity is not one feature but a family with three postures: opt-in with an API, opt-out and already running with your data, and no API at all. Almost every mistake we found came from applying one posture's rule to another's feature.
Ben Van Aken8 min read - Testing
The XCUITest Speed-Ups We Measured and Dropped
Part 11 of our XCUITest series, closing the performance arc. Three optimisations that look large on paper and measured small: caching provisioning per class (2.1 percent of setUp), keeping the session across relaunches (under 1 percent) and seeding fixtures once per class (inside the noise). How to price a candidate before building it, what actually makes result bundles large, and ten rules for UI-test performance.
Ben Van Aken10 min read - Testing
Animations Off and Parallel Simulators: Measured XCUITest Speed-Ups
Part 10 of our XCUITest series. Where XCUITest's wait-for-idle time comes from (not activate()), how to disable SwiftUI and UIKit animations from inside the app under a UI-testing launch argument without persisting anything, how to measure the effect with a pre-registered ABA run, and how to split a suite across parallel simulator clones by shared state. Measured at minus 7.70 percent and minus 20.0 percent, with do's and don'ts.
Ben Van Aken12 min read - Testing
Negative Waits: The Seconds Every Green XCUITest Run Burns
Part 9 of our XCUITest series. XCTAssertFalse(x.waitForExistence(timeout: 4)) spends four seconds on every passing run; waitForNonExistence spends one poll. A guide to the waits whose cost does not depend on the app: how to find them in the result bundle, how short each can safely be, how to prove a shortened wait can still fail, and the positive waits that never succeed. With do's and don'ts.
Ben Van Aken10 min read - Testing
The Launch-and-Login Tax: Per-Class App Lifecycle in XCUITest
Part 8 of our XCUITest series. When 84 percent of a test's setUp is launching the app and logging in, launching once per class is the first optimisation to consider. How to implement it in XCTest, how to prove the app is reset between tests, which classes must stay per-method, and how to skip wrong-device tests before the launch happens. Measured at minus 31.9 percent across 23 classes, with do's and don'ts.
Ben Van Aken11 min read - Testing
Measuring an XCUITest Suite Before You Speed It Up
Part 7 of our XCUITest series, and the start of the performance arc. A practical guide to measuring a UI-test suite before optimising it: which four numbers to collect, how to get a run that can be reported, how to read outcomes from the result bundle, when a before/after comparison is valid, how to confirm which build you measured, and why macOS runs cannot be left unattended. With do's and don'ts for each step.
Ben Van Aken10 min read - Testing
Diagnosing a Red XCUITest: Environment, Order, and Process
Part 6 of our XCUITest series. Stale binaries, simulator contention, automation-mode timeouts and dead hosts; the ten-step diagnosis order that stops you blaming the product; the process that keeps a suite honest; and the ten lines to keep if you keep nothing else.
Ben Van Aken7 min read - Testing
Oracles and Isolation: When a Green XCUITest Proves Nothing
Part 5 of our XCUITest series. A login smoke test that was vacuous for its entire life, Bool helpers that hid a live product defect, skips that report green, a restored session that donates the wrong identity to every later class, and the rules that fix each one.
Ben Van Aken7 min read - Testing
XCUITest Mechanics: Waits, Hittability, and Platform Traps
Part 4 of our XCUITest series. Why a leg's wall-clock is its query count times 19 seconds, why activate() inside a poll costs a minute, why isHittable is not visibility, the tap that landed on another app, and the iPad, iPhone and macOS traps that name the wrong subsystem.
Ben Van Aken12 min read - Testing
SwiftUI Accessibility Identifiers: Why Your Stamp Never Surfaces
Part 3 of our XCUITest series. Container ids overwrite their children, the Button authoring form decides what iOS publishes, a macOS Table is an Outline, menus keep their names on title, and a dozen other measured reasons a stamped identifier never reaches the tree.
Ben Van Aken7 min read - Testing
Designing an XCUITest Harness the App Cooperates With
Part 2 of our XCUITest series. One base class, two byte-identical lanes, structural assertions next to AI-vision contracts, a double-gated --uitesting launch argument, and the hidden-button trick that opens any seeded record in a lazy Table.
Ben Van Aken9 min read - TestingFeatured
Where UI Tests Belong in a SwiftUI App
Part 1 of our XCUITest series. The five-layer pyramid we test a production SwiftUI app with, why Apple forces the Swift Testing and XCTest split, the millisecond-cheap source-scanning guards, and seven shapes of coverage that cannot fail.
Ben Van Aken6 min read - SwiftUIFeatured
On-Device Translation with Apple's Translation Framework (The Session You Can't Keep)
A TranslationSession is only valid inside the closure that hands it to you. That single constraint decides the batching, the caching and the shape of every object around it.
Ben Van Aken10 min read - SwiftUIFeatured
Tracking ScrollView Offsets in SwiftUI (Three Ways That Actually Work)
The PreferenceKey snippet everyone copy-pastes silently reports a frozen 0.0. The coordinate space isn't why. Here's the fix, plus scrollPosition(id:) and onScrollGeometryChange.
Ben Van Aken11 min read - SwiftUI
Building an In-App Feedback Loop for Your SwiftUI App
Feedback scattered across App Store reviews, email and TestFlight isn't a collection problem. It's a loop problem. Here's how to build the loop in SwiftUI.
Ben Van Aken7 min read - iOS for Business
iOS App Security for Businesses: What Actually Protects Your Data
iOS gives you strong defaults and then stops. Where the platform's guarantees end and yours begin: Keychain and the Secure Enclave, App Attest, ATS and pinning, data-at-rest protection classes, privacy manifests, why jailbreak detection is not a control, and what auditors actually ask.
Ben Van Aken10 min read - iOS for Business
Why Mobile App Development Matters for SMEs (and When It Doesn't)
"Every business needs an app" is a sales pitch, not an answer. What mobile actually changes for a small or mid-sized business, what drives the cost, and how to tell whether you're one of the companies that shouldn't build one.
Ben Van Aken11 min read - Architecture
Scaling Swift Projects With Modular Packages
Seven local packages, one Vapor binary, four public domains. What splitting a Swift project into modules actually buys you, the rule that makes it work, the bug it did not prevent, and when not to bother.
Ben Van Aken11 min read - SwiftUI
SwiftUI vs UIKit: A 2026 Answer, Not a 2020 One
Six years on, this is not a choice between two frameworks. It is a ratio, and every app we ship has both in it. What SwiftUI still does badly, how to bridge in both directions, and how to pick per project.
Ben Van Aken12 min read - Architecture
MongoDB and SwiftUI: The Decision First, Then the Wiring
Swift and MongoDB are not alternatives. But there is a real decision hiding behind that search. Here's when Mongo beats Postgres for a Swift backend, why the old SwiftUI shortcuts are gone, and the wiring that still works.
Ben Van Aken12 min read - SwiftUI
The Swift Logger API, End to End
Unified logging is the best-documented Apple API that almost nobody uses properly. Subsystems, the privacy rules that redact your strings, signposts, pulling logs off a device, and why the server wants a different Logger entirely.
Ben Van Aken13 min read - iOS for Business
From Prototype to App Store: A Realistic Timeline
The real sequence from an idea to a live listing: discovery, prototype, MVP, TestFlight beta, App Review, launch. Honest durations for each stage, what actually causes rejections, and the admin that has to start weeks before you think it does.
Ben Van Aken9 min read - iOS for Business
Apple vs Android for Business: How to Choose a Device Fleet
Not a flamewar. How Android and iOS genuinely differ as software, which platform gives you more accessible support, which app store is actually safer, and how to pick the right devices for a company fleet. Written by a studio that ships on both.
Ben Van Aken9 min read
No articles match your search
Try a different word, or clear the search.