All articles
developers

Build vs. Buy Wallet Passes: The Real Cost of Running Them Yourself

Building wallet passes in-house looks like a three-point ticket. Here is the full bill in hours and dollars, and when paying it still makes sense.

Build vs. Buy Wallet Passes: The Real Cost of Running Them Yourself
Julio Song
11 min read

It's sprint planning on a Monday, and the ticket on the screen says "Add to Apple Wallet." Someone on your team already tried it over the weekend. They pulled an open-source library, exported a certificate, and got a signed pass onto their own phone in an afternoon. The room agrees on three points, and the ticket goes into the sprint.

Six weeks later the same ticket has four children. One is for the update service. One is for push. One says "Android?" and has no estimate. The last one is a calendar reminder about a certificate.

Nobody lied in that planning meeting. The estimate was accurate for the work the team had seen. This post prices the work it hadn't seen yet, in hours and in dollars, so you can make the build or buy call before the sprint and not after it.

The three-point ticket is for a different project

Generating a pass and running a pass program are two jobs that share a search term. The first is a file. You hash some JSON and a few images into a manifest, sign it with your Pass Type ID certificate, and zip it. A library does this well, and we've compared the leading library against a hosted API piece by piece.

The second job starts the moment a pass has to change. Apple's documentation describes an update as "a cooperative effort between the user's device, Apple servers, and your server," and then lists what your server owes that effort. You store three tables: devices, passes, and the registrations that join them. You answer the calls that register and unregister a device, list the serial numbers that changed, and return a freshly signed pass. You send a push to every registered device when something changes. You delete a device when Apple's push service says its token is dead.

That's a small web service with a database, a signing path, and a long-lived connection to Apple. None of it is hard computer science. All of it is yours to build, test, and keep running.

Then there's the second wallet. Google Wallet shares none of this. A pass there is a class and an object, wrapped in a JWT that you sign with a Google Cloud service account key. You'll write it as a separate integration, and the single pass model post covers what it takes to keep the two in step.

What you're actually signing up to build

Here is the whole list with hours beside it. These are estimates for one experienced developer who hasn't built wallet passes before. They aren't measurements, and you should replace them with your own. The low column assumes everything works the first time.

WorkLow (hours)High (hours)
Certificate chain, key export, signing in CI816
Pass design, images, generation with a library1624
Update web service and its three tables2440
Push sender, retries, dead-token cleanup2460
Google Wallet: issuer account, classes, JWT, publishing review2440
Device testing, logging, alerts1624
Total112204

That's roughly three to five weeks of one person's time. The weekend prototype covered most of row two.

The spread is widest on push, and there's a reason for that. Apple's guide gives the push two bullets, but the work behind them is a persistent HTTP/2 client and a retry policy. We walked through all of it in push updates without an APNs server. Apple also notes that a push for a pass update "works only in the production environment," so you can't rehearse against a sandbox. You test with real devices against the real service, and each failed attempt takes a real person's time.

After launch the work continues at a lower rate. Somebody renews the certificate every year. Somebody answers the support ticket when a balance didn't refresh. Somebody reads the release notes when Apple or Google changes a requirement. A fair guess is two to four hours a month. Some months it will be zero. The month the certificate lapses, it won't be.

Put a price on an hour

Hours only matter to a budget once they have a price. The U.S. Bureau of Labor Statistics puts the median wage for software developers at $135,980 a year as of May 2025. Divide by 2,080 working hours and you get about $65 an hour.

That figure is conservative on purpose. It leaves out benefits, payroll tax, equipment, and management time, and a contractor would charge well above it. If the build still looks expensive at $65, it will look worse at your real rate.

Here is the arithmetic as code, so you can change the inputs. The fee is Passmint's Pro plan at $49 a month, which covers 5,000 active passes.

const hourly = 135980 / 2080 // BLS median developer wage, May 2025

const build = { hours: [112, 204], upkeepPerMonth: [2, 4], monthlyFee: 0 }
const buy = { hours: [8, 16], upkeepPerMonth: [0, 0], monthlyFee: 49 }

function threeYearCost({ hours, upkeepPerMonth, monthlyFee }) {
  return hours.map((h, i) =>
    Math.round((h + upkeepPerMonth[i] * 36) * hourly + monthlyFee * 36),
  )
}

console.log(threeYearCost(build)) // [ 12029, 22751 ]
console.log(threeYearCost(buy)) // [ 2287, 2810 ]

Over three years, building runs roughly $12,000 to $22,750 in labor. Buying runs roughly $2,300 to $2,800, most of it the subscription. Apple's $99 annual membership isn't in either number because you pay it both ways.

The initial build is only about 60 percent of the build total. The rest is upkeep, which is the part nobody estimates in sprint planning. The gap is also wide enough to survive bad inputs. Halve the build hours and double the subscription, and building still costs more.

The costs that don't fit in a spreadsheet

The table prices the work you can see coming. A few costs don't arrive as hours on a ticket.

The certificate has a clock on it. A Pass Type ID certificate expires about a year after Apple issues it. Apple's support page says what happens next: installed passes "continue to function normally," but "you'll no longer be able to sign new passes or send updates to existing passes." Nothing looks broken until the day a customer can't add a pass, and we've written up exactly what breaks. The renewal itself is quick. What costs you is the morning spent ruling out everything else first.

One file carries two jobs. Apple's guide says the push "uses the same certificate and private key" that signed the pass. So the key that proves your passes are yours also has to live wherever your push sender runs. Now you have a secret in two places, and a storage problem to solve in both.

Google has a waiting room. A new Google Wallet issuer account starts in demo mode. Your passes carry a "[TEST ONLY]" label and reach only your admins, developers, and listed testers until Google's team reviews your request for publishing access. The review asks for a business profile. It's not difficult, but it's calendar time you don't control, and it lands at the end of the project when you have the least slack.

The author leaves. This is the cost teams feel last. A pass service runs for months without a deploy. The person who knew why the authentication token must never change in an update has moved to another team by the time it matters. Apple's guide warns you not to change it, because some devices will still hold the old pass. That warning lives in one developer's memory unless you write it down.

A gym chain runs the numbers

Consider a representative regional gym chain, based on an anonymized example. It has about 4,000 members, a backend team of five, and a plastic key tag it wants to retire. The membership card should live in the wallet, show the home club, and flip to "frozen" when a member pauses.

The lead developer scopes it at two weeks. Generation takes three days, which matches the plan. The update service takes eight, because "frozen" has to reach the phone and that means registrations, change tags, and push. Android wasn't in the original scope. Front-desk staff ask about it in week three, when a third of the members at one club can't add the card. Google Wallet adds another six days, plus the wait for publishing access. Device testing and alerts take two more.

The total comes to 19 working days, about 150 hours, spread across five calendar weeks. At the median wage that's roughly $9,800, inside the range in the table. The team ships, and the card works.

The bill they didn't plan for comes eleven months later. The certificate expires on a weekend. New members can't add a card on Monday, and paused memberships stop showing as frozen at the door. The developer who built the service has moved to the billing rewrite. It takes most of a day to find the cause and a few minutes to fix it.

Here's the comparison the lead runs afterward. Four thousand active passes fits a $49 plan. Three years of that is $1,764. The first build alone cost more than five times as much, before upkeep and before the lost Monday. The service itself is well built. The lead's conclusion is that a pass pipeline is the wrong thing for five backend developers at a gym to own.

What buying costs, and what you still own

Buying has a price too, and a fair comparison includes all of it.

The subscription. Passmint's paid plans are $15 a month for 500 active passes, $49 for 5,000, and $149 for 25,000, with a cent per extra pass above the limit. There's a free tier with 10 active passes and the full API in test mode, which is enough to build the integration before you pay anything. Other vendors price differently, and our comparison of seven options covers the range.

The integration. It's small, but it isn't zero. Issuing a pass is one call:

import { Passmint } from "@passmint/node"

const passmint = new Passmint({
  apiKey: process.env.PASSMINT_API_KEY!,
})

const pass = await passmint.passes.create({
  templateId: "tmpl_xxx",
  holderEmail: "alice@example.com",
  holderName: "Alice Johnson",
  fieldValues: { homeClub: "Riverside", status: "Active" },
})

Freezing that membership later is another:

await passmint.passes.update(pass.id, {
  fieldValues: { status: "Frozen" },
})

The registrations, the signing, the push, and the Google object update happen behind that second call. Budget a day or two for the integration, including a webhook handler if you want to know when a pass is installed.

The parts that stay yours. You still need the Apple Developer Program membership for live Apple passes, because Apple ties a pass to the brand that issues it. You still do the certificate exchange once a year. Passmint generates and stores the private key and emails you before expiry, but the Apple account is yours and so is the click.

The dependency. A vendor can raise prices, change an API, or go away. Ask what leaving would take before you sign up. Your Pass Type ID belongs to your Apple account and not to the vendor, so the identity of your passes goes with you. Moving the passes already on phones is still a migration you'd have to plan.

When building is still the right answer

The arithmetic favors buying for most teams, but four situations change it.

  • The key can't leave your hardware. Some security policies require the signing key to stay in a hardware module you control. A hosted signer is ruled out, and the build cost is the cost of compliance.
  • Passes are your product. If you sell ticketing or loyalty software to other businesses, the pass pipeline is core work. You'll want to own it the way you own your database schema.
  • You already run push. A team with an existing push service, dashboards, and on-call cover has paid for the most expensive row in the table. Adding a pass topic costs far less than starting from nothing.
  • Your volume is very large. Per-pass fees grow with your audience. Engineering upkeep mostly doesn't. At some number of active passes, a part-time engineer costs less than the invoice. Run the script above with your own volume and find that number before you assume you've reached it.

If none of those describe you, the three-point ticket is the expensive option. You can check that in an afternoon. The Passmint quickstart issues a test pass with no Apple account and no card, and you can time how long it takes you against the table above.

Primary sources

Common questions

For most teams the API is cheaper. Using the U.S. median developer wage, a self-built stack for both wallets costs roughly $12,000 to $22,750 over three years in labor alone, against roughly $2,300 to $2,800 for a hosted plan at $49 a month plus integration time. The numbers are estimates, so rerun them with your own.
Generating the first signed pass takes an afternoon with an open-source library. The full program, with the update web service, push delivery, Google Wallet and monitoring, is closer to three to five weeks of one developer's time, and then a few hours of upkeep every month.
Yes, for live Apple Wallet passes. Apple ties each pass to the Pass Type ID of the brand that issues it, so the $99 annual Apple Developer Program membership sits on both sides of a build-versus-buy comparison.
When the signing key has to stay on hardware you control, when passes are the product you sell, when you already run a push service with on-call cover, or when your volume makes a per-pass fee larger than a part-time engineer.
Julio Song

Technical content writer, Passmint

Julio is a technical content writer at Passmint. He writes about Apple PassKit, the Google Wallet API, and what breaks when wallet passes meet production traffic.

More from Julio Song →

Related reading

Share this article