Build With Me / Apple
Build your Apple app with me.
iPhone, iPad, Mac, Apple Watch, Apple TV, Vision Pro: one language, six different products.
A native Apple app is written in Swift, with SwiftUI for the interface, in Xcode on a Mac. Business logic shares well across devices; the interface, navigation and system features are designed device by device. Publishing on the App Store or testing with TestFlight requires the Apple Developer Program (99 USD per membership year, or local currency where available).
Checked on
In brief
- Language
- Swift; SwiftUI for the interface, with UIKit or AppKit where needed
- Tool
- Xcode, which runs only on a Mac
- Account
- Apple Developer Program: 99 USD per membership year (or local currency) for TestFlight and the App Store
- Current versions
- iOS, iPadOS, macOS, watchOS, tvOS and visionOS 27; Xcode 27.1 (October 2026)
- Minimum to publish
- Xcode 26 and the 26 SDKs, since 28 April 2026
- Review time
- Per Apple: at least 50% of submissions reviewed in under 24 hours, 90% in under 48 hours
Apple platforms
Three ways to build
Learn, build it together, or have it built.
Learn and build
The path runs on the guides on these pages and Apple’s official tutorials (Develop in Swift, SwiftUI tutorials). Build School teaches how to build web products, not Swift: there is no paid Bynilson course for Apple apps.
Build together
You build; Bynilson reviews and guides in writing: scope, architecture, milestones. Reviewed case by case — there is no native app published in the Bynilson portfolio yet, and the answer may be a referral to a specialist.
Have it built
Bynilson does not deliver native mobile apps (iPhone, iPad, Apple Watch). A Mac app is reviewed case by case. For mobile, the project builder produces a roadmap and a brief to hand to a specialist iOS studio.
Bynilson does not deliver native mobile apps: the builder gives you the roadmap and the brief to hand to a specialist studio. A request for guidance (you build, with an outside review) is reviewed case by case.
01 — Native
What “native” means on Apple platforms
A native app is written for the platform, with Apple’s tools and frameworks. It reaches everything the device offers, and it lives in the App Store.
In practice: Swift code compiled for the device, a SwiftUI interface that follows each platform’s conventions, and direct access to system features — widgets, notifications, Shortcuts and Siri through App Intents, in-app purchase, health data with HealthKit, camera, location.
- Native is the right call when…
- the product depends on the device (sensors, camera, health, widgets, Shortcuts), must work offline, benefits from being in the App Store, needs smooth animation, or must also exist on Apple Watch or Mac.
- It probably is not when…
- the product is mostly forms and content, also used on a computer; when you need Android at the same time with a small team; or when you first need to find out whether anyone wants it. A phone-friendly web app tests demand faster.
- A website in an app wrapper is not enough
- App Store rule 4.2 asks for features, content and interface that go beyond “a repackaged website”. If that is all your product is, stay on the web.
02 — Shared code
What shares across devices — and what does not
Swift and SwiftUI exist on all six platforms. That does not mean one SwiftUI project ships unchanged everywhere.
What shares well: the data model, business rules, validation, networking, local storage (SwiftData, available since iOS 17, macOS 14, watchOS 10, tvOS 17 and visionOS 1). It goes in a shared Swift package, tested once.
| Device | Input | Navigation and windows | Specific (checked in Apple’s documentation) |
|---|---|---|---|
| iPhone — iOS | Touch, often one-handed | Navigation stacks, tabs | Widgets (WidgetKit, iOS 14+), HealthKit, in-app purchase |
| iPad — iPadOS | Touch, pointer (since iPadOS 13.4), keyboard, Apple Pencil | Split views; resizable windows and a menu bar since iPadOS 26 | PencilKit for drawing; iPhone apps should run on iPad whenever possible (rule 2.4.1) |
| Mac — macOS | Pointer, keyboard, shortcuts | Multiple windows, menu bar, settings window | MenuBarExtra (macOS 13+, Mac only); App Sandbox for the Mac App Store, Developer ID outside it |
| Apple Watch — watchOS | Touch, Digital Crown, glances of a few seconds | Short screens, shallow hierarchy | Complications through WidgetKit (watchOS 9+); a few seconds of background time, only with a complication on the active watch face |
| Apple TV — tvOS | Siri Remote | Focus-based navigation (the focus engine) | No WidgetKit; Top Shelf content through an extension |
| Vision Pro — visionOS | Eyes and hand gestures | Windows, volumes, immersive spaces | ImmersiveSpace (visionOS only); a compatible iPhone/iPad app runs without a visionOS destination |
- Share: model, rules, validation, networking, persistence, translated strings.
- Write per device: navigation structure, input handling, windows and scenes, system extensions (widgets, complications, menu bar).
- Prepare per device: screenshots, listing, Apple’s review — and often one build per platform.
03 — Ecosystem
One product across several Apple devices
iPhone and Watch, iPhone and Mac, iPad and Mac: the questions are always the same — who holds the data, how it syncs, and what each device does on its own.
- Companion apps
- Since watchOS 6, a Watch app can be independent, with no iPhone app required; Apple recommends that approach where possible. A companion Mac or iPad app shares the Swift core, not necessarily the interface.
- Sync: CloudKit or your own server
- CloudKit stores data in iCloud, and SwiftData can sync a person’s data across their devices automatically. That stays simple while all your users are on Apple. You need your own server with Android or the web, server-side logic, an admin back office, or data you must analyse and export.
- Shared accounts
- One account on every device. If you offer sign-in through a third-party service (Google, Facebook…), rule 4.8 requires an equivalent login option that limits data to name and email and lets people keep their email private. If the app lets people create an account, it must also let them delete it in the app (5.1.1(v)).
- App Groups
- A container shared between your app and its extensions on the same device — so a widget can read the app’s data, for example.
- Keychain sharing
- Apps from the same team share credentials through a keychain access group. Secrets go in the keychain, never in the app’s settings.
- Subscriptions
- An auto-renewable subscription must be available across all of the person’s devices (rule 3.1.2(a)): design your accounts for it from the start.
- Release preparation per platform
- TestFlight covers iOS, macOS, tvOS, watchOS and visionOS. Each platform has its own screenshots, listing and review: plan one release preparation per device, not one in total.
04 — Technologies
Apple’s technologies, and when they help
Not a checklist: every tool has a case where it helps and a case where it gets in the way.
Swift
The language of Apple apps: typed, compiled, safe by default.
When: Always, for a native app.
SwiftUI
The declarative interface framework, on all six platforms.
When: New apps and most screens.
Not when: A specific component is missing: wrap a UIKit or AppKit element instead of rewriting everything.
UIKit
The long-standing interface framework of iOS, iPadOS and tvOS.
When: An existing codebase, fine control over a complex screen.
Not when: A new, simple app: SwiftUI is enough.
AppKit
The Mac’s native interface framework.
When: Advanced Mac behaviour: complex text, document architecture, fine window control.
Not when: A standard Mac app that SwiftUI covers.
Xcode
The development environment: editor, simulators, signing, upload to App Store Connect. Mac only.
When: Always.
Swift Package Manager
Swift packages: share code between targets and add dependencies.
When: A core shared by several devices.
Not when: Adding a package for something the SDK already does.
StoreKit — in-app purchase
The Swift in-app purchase and subscription API (iOS 15+, macOS 12+).
When: Selling digital content or features inside the app: it is required (rule 3.1.1).
Not when: Physical goods or services consumed outside the app: you must use another payment method (rule 3.1.3(e)).
CloudKit
Apple’s database in iCloud.
When: An all-Apple app that syncs its users’ data with no server to run.
Not when: Android or web users, server-side logic, data you must administer centrally.
SwiftData / Core Data
Structured local storage. SwiftData since iOS 17 and macOS 14; Core Data, older, for earlier versions.
When: Offline data, a cache.
Not when: Data that must live on a server anyway: keep a cache, not a second source of truth.
App Intents
Make the app’s actions and content available to Siri, Spotlight, Shortcuts, widgets and Apple Intelligence (iOS 16+, macOS 13+).
User Notifications
Local notifications, or notifications pushed from a server.
When: Expected, useful information at the right moment.
Not when: Promotion without explicit consent: rule 4.5.4 forbids it, and a notification must never be required for the app to work.
WidgetKit
Widgets, watch complications, Live Activities and controls.
When: Information people check at a glance.
Not when: On tvOS: WidgetKit does not exist there.
App Groups
A container shared between the app and its extensions.
When: A widget or extension that reads the app’s data.
Keychain
Encrypted storage for passwords and tokens.
When: Every secret or sign-in token.
Not when: Never put a secret in UserDefaults or a file.
Core ML
Run machine-learning models on the device.
When: Classification, recognition, offline and without sending data away.
Not when: You need a large language model: see Foundation Models or a server API.
Foundation Models
Apple’s language models, on device or through Private Cloud Compute (iOS, iPadOS, macOS, visionOS 26+; watchOS 27+).
When: Summarise, extract or rewrite text while keeping data on the device.
Not when: The app must work on every device your users own: the framework needs a device that supports Apple Intelligence — plan a fallback.
05 — Accounts
Which account you need, and what it costs
- Free Apple Account
- Enough to learn and test on your own devices with Xcode. Limits Apple states: up to 3 devices, 3 apps per device, and provisioning profiles that expire after 7 days (you reinstall from Xcode).
- Apple Developer Program
- 99 USD per membership year, or local currency where Apple offers it. Required for TestFlight, App Store Connect, publishing, Mac notarization and certificates.
- Developer ID (Mac outside the App Store)
- The certificate that lets you distribute a Mac app outside the Mac App Store. It is part of the paid program and only the team’s Account Holder can generate it.
- What this site does not price
- What a native app costs to build depends on the number of screens, the devices targeted, any server, and the system features. Bynilson does not publish a price for native apps and does not make one up.
06 — Distribution
How an Apple app reaches people
- App Store
- The main route on iPhone, iPad, Watch, Apple TV and Vision Pro. Every version goes through App Review; the decision is Apple’s.
- TestFlight
- The beta: up to 100 internal and 10,000 external testers, each build testable for 90 days. The first build sent to external testers may need review.
- Mac outside the App Store
- A Mac app can be distributed directly, signed with Developer ID and notarized by Apple (an automated check, not App Review). The Mac App Store requires the App Sandbox.
- Custom apps for organisations
- Apple provides private distribution of apps to specific organisations (“custom apps”); the conditions are in Apple’s documentation.
- European Union
- In the EU, the Digital Markets Act opens alternatives (payments, web distribution of notarized apps, alternative marketplaces) with their own conditions and fees; read Apple’s page before planning around them.
07 — Testing
Testing: simulator, devices, testers
- Xcode’s simulator (iOS, iPadOS, tvOS, visionOS, watchOS) to iterate quickly.
- Real devices for anything involving sensors, performance, notifications and battery: the simulator does not replace an iPhone.
- Swift Testing (Xcode 16+) or XCTest for business rules and the shared core.
- TestFlight so real people test before release.
08 — Maintenance
An Apple app is maintained every year
Apple ships a new version of every operating system each year and regularly raises the minimum to publish. Since 28 April 2026, apps uploaded to App Store Connect must be built with Xcode 26 or later and a 26 SDK; since 9 September 2026, iPhone and iPad apps must target iOS 13 or later.
- Rebuild and retest at every major OS release.
- Track deprecated APIs (ClockKit complications, for example, are deprecated since watchOS 10 in favour of WidgetKit).
- Read Apple’s “Upcoming requirements” page before planning a release.
Frequently asked questions
Do I need a Mac to build an iPhone app?
For a native app, yes: Xcode runs only on a Mac. Some cross-platform tools build the iOS app in the cloud, but you still need an Apple Developer account to publish.
Does the same SwiftUI code run on iPhone, Mac and Apple Watch?
The core (model, rules, networking) shares. The interface and navigation are designed per device, and some APIs exist on one platform only (MenuBarExtra on Mac, ImmersiveSpace on visionOS). Plan one interface layer per device.
How much does the Apple developer account cost?
99 USD per membership year, or local currency where Apple offers it. A free account is enough to test on your own devices, with limits (3 devices, 7-day profiles).
CloudKit or my own server?
CloudKit if all your users are on Apple and you sync their own data. Your own server as soon as there is Android, the web, server-side logic or data to administer.
Can Bynilson build my iPhone app?
No: Bynilson does not deliver native mobile apps. The project builder produces a roadmap and a brief to hand to an iOS studio, and the hire or outsource guide helps you decide how to staff it. A Mac app is reviewed case by case.
How long does Apple’s review take?
Apple says it reviews at least 50% of submissions in under 24 hours and 90% in under 48 hours. Approval remains Apple’s decision; no timing or outcome is guaranteed here.
Sources
- SwiftAppleChecked on 23 Oct 2026
- SwiftUI documentationAppleChecked on 23 Oct 2026
- UIKit documentationAppleChecked on 23 Oct 2026
- AppKit documentationAppleChecked on 23 Oct 2026
- XcodeAppleChecked on 23 Oct 2026
- Swift packagesAppleChecked on 23 Oct 2026
- StoreKitAppleChecked on 23 Oct 2026
- CloudKitAppleChecked on 23 Oct 2026
- SwiftDataAppleChecked on 23 Oct 2026
- App IntentsAppleChecked on 23 Oct 2026
- User NotificationsAppleChecked on 23 Oct 2026
- WidgetKitAppleChecked on 23 Oct 2026
- Configuring App GroupsAppleChecked on 23 Oct 2026
- Keychain ServicesAppleChecked on 23 Oct 2026
- Core MLAppleChecked on 23 Oct 2026
- Foundation ModelsAppleChecked on 23 Oct 2026