Richato
A crypto and Forex trading-signals app: a rebuilt notification pipeline, full localization, and a StoreKit payment path built to satisfy App Store rules for a fundamentally crypto-native subscription business.
- Role
- iOS Engineer
- Platform
- iOS
- Stack
- Swift · StoreKit · Push Notifications · Localization
- Scale
- Multi-language · dual payment paths · shipped to the App Store
Signals, not custody.
Richato delivers crypto and Forex trading signals. It's a subscription service, not a broker or an exchange: people use it for buy/sell/hold guidance across short-, medium-, and long-term positions, then act on that guidance wherever they already trade. I worked on the iOS app, closing out a significant backlog of bugs, rebuilding its notification system, adding full localization, and building out its Apple StoreKit payment path, then took it through to release.
The problem
Richato's business runs on crypto-native subscription payments, priced and paid in Tether. Apple's App Store rules require digital subscription content sold inside an app to go through StoreKit's in-app purchase system, not an external crypto payment flow. That's a genuine mismatch: the business's native payment model and the platform's rules don't naturally agree. The iOS app had to reconcile the two, and it had to stay reliable enough that people would trust it enough to pay for trading signals in the first place.
Constraints
- App Store compliance requires StoreKit for in-app digital subscriptions. The app couldn't simply mirror the business's crypto-native payment model inside the client.
- A signals product lives or dies on delivery. A missed or late notification is the entire subscription failing to deliver, regardless of how good the underlying signal is.
- A genuinely international subscriber base needed real multi-language support, not an English-only app with translated store copy.
- An already-active paying subscriber base. Bug fixes and a payment-system overhaul both had to land without breaking the experience for people already relying on the app.
Two payment paths, one entitlement.
The client keeps StoreKit purchases and the platform's crypto-based subscriptions reconciled against the same entitlement state. A subscriber is a subscriber, however they paid.
Compliance as a design problem, not a checkbox.
A full StoreKit path, not a crypto-payment shortcut
Built a complete in-app purchase flow through StoreKit instead of routing App Store users toward the platform's crypto and Tether payment flow directly. App Store approval of digital subscription content required it, and the new flow reconciles against the same subscription state crypto-paying users already share.
Rebuilt the notification pipeline
Rebuilt how incoming trading signals are delivered as push notifications, replacing the existing pipeline outright. A signals subscription's entire value is timely delivery; a slow or missed notification is a failed subscription no matter how good the underlying analysis is.
Full localization for a global subscriber base
Crypto and Forex signals attract a genuinely international audience, so multi-language support went into the app itself rather than staying limited to translated marketing copy layered on top of an English-only product.
Bug backlog before new features
The significant existing bug backlog got closed out alongside the new work, not after it. An already-active paying subscriber base needed a more trustworthy app before it needed a more feature-complete one.
What reconciling two payment models cost.
StoreKit compliance over one unified payment flow
App Store approval, and access to iOS users at all for a subscription product.
Two parallel payment paths (StoreKit and crypto) had to be kept in sync in the subscription and entitlement state, instead of one simpler system.
Rebuilding notifications over patching them
A signal-delivery pipeline reliable enough to carry the product on its own.
Real engineering time went into delivery infrastructure at the expense of user-facing features, in an app whose backlog already had plenty of both competing for attention.
Bug fixes before new features
A more trustworthy app for an already-paying subscriber base, the thing a signals product needs most to keep people subscribed.
Slower visible feature velocity for a stretch of the work, in exchange for reliability that doesn't show up in a changelog.
Where the platform's rules meet the business model.
A crypto-native business, on a platform that doesn't work that way
The business already had a working Tether-based subscription model. Making the iOS app App-Store-compliant meant building a genuinely separate StoreKit purchase path, then keeping its entitlement state consistent with the crypto side, even though the two payment systems shared nothing under the hood.
Making notifications trustworthy for a paid product
A subscription service selling trading signals depends entirely on those signals arriving promptly. Rebuilding the notification pipeline was less about a specific bug and more about making delivery something the product — and its subscribers — could actually rely on.
Localizing a live app without breaking existing subscribers
Adding multi-language support to an app already in people's hands meant rolling it out without disrupting the experience for subscribers who were already paying and already using it daily.
What shipped.
A narrower surface than it looks.
Richato isn't a fund manager, a broker, or an exchange. It doesn't hold or move user funds, and subscribers act on its guidance wherever they already trade. That materially narrows what the iOS client needs to secure. The real trust boundary is payment integrity: StoreKit purchases are verified through Apple's own purchase-validation, and reconciled against the platform's separate crypto-payment entitlement records so a subscriber's access is correct regardless of which path they paid through.
From backlog to release.
Working through the bug backlog
Started by closing out a significant existing backlog of bugs on an app with an already-active paying subscriber base.
Notification pipeline rebuilt
Rebuilt signal delivery from the ground up, treating notification reliability as core to the product rather than a peripheral feature.
StoreKit path built and reconciled
Built the full in-app purchase flow through StoreKit and reconciled it against the platform's existing crypto-based subscription and entitlement state.
Multi-language support added
Rolled out full localization for an international subscriber base, without disrupting people already using the app.
Shipped
Took the app through to release with a smaller bug backlog, a rebuilt notification system, full localization, and a compliant payment path in place.
What a platform's rules can teach you about your own architecture.
- Platform compliance can be a bigger technical problem than the business logic itself. Reconciling StoreKit with a crypto-native subscription model took as much design care as any user-facing feature.
- For a paid signals product, delivery infrastructure is the product. Subscribers are paying for notification reliability as directly as they're paying for the signals themselves.
- Fixing the backlog earns the right to add features. A paying subscriber base notices reliability before it notices anything new.
Compliant, reliable, and shipped.
Richato's iOS app shipped with a rebuilt notification pipeline, full localization, and a StoreKit payment path that satisfies App Store rules while staying reconciled with the platform's crypto-native subscription model. It also shipped with a meaningfully smaller bug backlog than when the work started.