Skip to content
AppDues
Log in
Contact salesSign up

StoreKit implementation: building subscriptions yourself or using a platform

A developer with long StoreKit experience compares a hand-built subscription system with a later platform integration. The contrast is not mainly about writing the first purchase code; it is about sandbox testing, server validation, integrations, analytics, incident cover, and yearly Apple release work.

Why this experience is useful

The interviewee had used StoreKit since its introduction in 2009 and had shipped apps across Apple platforms for many years, including client and employer work and personal projects. That background matters because the estimates below come from someone who already knew in-app purchase patterns, rather than a first-time implementer.

The hand-built build: two weeks before the surrounding work

The initial hand-built StoreKit logic took about two full-time 40-hour weeks. The developer reused code from earlier projects, and the goal was a generic design so future offerings could be added without major rework. Android in-app purchase was not attempted, and the time spent by a Node engineer on server-side validation was separate and unknown.

The real difficulty is the edge cases

Reading the API documentation and wiring up the basic flow was not the main difficulty. The hard parts were poorly documented or undocumented behaviour around Apple's infrastructure: getting App Store Sandbox accounts to test correctly, and accelerated sandbox subscription events that did not reliably match the sparse specification. Building a Mac app for the first time was singled out as especially difficult. A useful checklist before committing to a hand-built approach is: sandbox account setup, subscription event simulation, receipt validation, server operations, incident cover, analytics integrations, and the annual Apple release cycle.

Server validation and who answers at 2 a.m.

Receipt validation ran on Node and Postgres hosted on AWS. One server developer owned the service day to day and was paged if it failed overnight. The mobile developer could advise from experience but did not have login access to fix incidents independently. When the App Store was unavailable for roughly five hours on 24 January, the interviewee had already left the company seven months earlier and could not confirm who responded; the concern was that at a small company nobody might have noticed at all.

Integrations are easy to start and hard to finish well

Simple integrations, such as posting to a Slack channel, were described as a single HTTP request added to an existing queue or notification system. Deeper integrations depended on the destination and took from a few hours to a week to do properly on the developer's own backend. For charts and analysis, building in-house was rejected: the preference was a drop-in SaaS or open-source tool, or nightly spreadsheet exports and hand-written SQL if nothing suitable existed.

Maintenance follows Apple's yearly cycle

Beyond outages, maintenance followed an annual rhythm: respond to Apple's June announcements, prepare a large update for the autumn, then triage and work around problems in the first public release that beta testing missed. Budgeting only for the initial build therefore understates the lifetime cost of a hand-built system.

Cost, time to market, and domain expertise

The decision factors were cost, time to market, and domain expertise. The developer favoured paying for tools that save time, even in a one-person company, and argued that years of Apple ecosystem experience still could not match a mature SDK plus accumulated payments expertise. The cited plan cost was compared with about two and a half days of freelance billable time, but current pricing must be confirmed separately. Open-source StoreKit wrappers were acknowledged, but they would not include server infrastructure or support.

A later integration reached a first purchase in 1 hour 21 minutes

In a later personal project, commit timestamps show integration starting at 10:02 p.m., a purchase UI mostly complete by 10:55 p.m., and free-trial information added by 11:23 p.m. From SDK installation to a first successful sandbox purchase with the UI reacting took 1 hour 21 minutes. Cleanup and polish remained, but the core transaction and receipt verification worked in under ninety minutes.

Hand-built StoreKit versus platform integration
AreaHand-built approachPlatform approach
Initial StoreKit logicAbout two full-time 40-hour weeks, reusing prior codeFirst sandbox purchase in 1 hour 21 minutes in a later project
Sandbox and subscription eventsUndocumented quirks and unreliable accelerated eventsHandled by the platform's accumulated expertise, per the interviewee
Server validationNode and Postgres on AWS, operated by one server developerServer infrastructure included, per the interviewee
Incident coverOne person paged overnight; mobile developer lacked login accessSupport and infrastructure included, per the interviewee
Integrations and chartsHours to a week per deep integration; charts not worth building in-houseIntegrations and analytics offered by the platform, subject to owner confirmation
Ongoing maintenanceAnnual cycle around Apple's June announcements and autumn releasesReduced client-side maintenance, per the interviewee

Based on one developer's reported experience in the interview; not a general benchmark.

Frequently asked questions

How long did a first StoreKit and subscription build take?

About two full-time 40-hour weeks for the initial StoreKit logic, even with prior in-app purchase experience. The build was kept generic so new offerings could be added with minimal extra work. Android in-app purchase was not attempted, and server-side validation time by a separate engineer was not counted in that estimate.

What made StoreKit harder than reading the documentation?

The basic API work was not described as the hardest part. The difficult areas were testing sandbox accounts correctly, accelerated sandbox subscription events that did not always follow the documented behaviour, and first-time Mac app development.

What server infrastructure was used and who operated it?

The server ran Node and Postgres on AWS. One server developer owned day-to-day operation and received pages if it went down, including overnight. The mobile developer did not have login access to respond independently in a crisis.

How long do analytics or messaging integrations take?

A simple Slack notification was described as a single HTTP request added to an existing queue or notification system. Deeper integrations varied widely, from a few hours to a week when done properly on the developer's own backend.

Should charts and subscription analysis be built in-house?

Building charts and analysis tools in-house was not recommended. The preferred fallback was a drop-in SaaS or open-source solution, or nightly exports to a spreadsheet and hand-written SQL if no suitable tool was available.

What ongoing maintenance do subscription apps require?

Maintenance was described as following annual cycles: reacting to Apple's June announcements, preparing a major update for the autumn, then triaging and working around issues in the first public release that were missed during beta testing. Infrastructure outages were separate from that cycle.

What were the main reasons for using a subscription platform?

The three factors were cost, time to market, and domain expertise. The developer favoured paying for tools that save time, and compared the cited annual plan cost to about two and a half days of freelance billable time. Open-source wrappers were mentioned, but without server infrastructure or support.

How long did a later platform integration take to reach a first purchase?

From installing the SDK to a first successful sandbox purchase with the app UI reacting took 1 hour 21 minutes. That was not the finished product; cleanup and additional niceties remained, but the core transaction and receipt verification worked in under ninety minutes.