App development

How we work: idea to App Store

App development at Klura runs as a short, legible sequence. You always know which step we're in, what it costs, and what comes out of it. Nothing here is theatre — each stage produces something concrete you can look at or use.

• 1. Scope. A first conversation to pin down what the app actually needs to do: the core flows, who uses it, whether it needs accounts, payments, or its own backend, and which platforms matter. You leave this step with an honest indicative range, not a sales pitch.
• 2. Shape. We turn the idea into a concrete screen-by-screen plan and a clear data model — what the app shows, what it stores, what it talks to. This is where a vague brief becomes a fixed, costable scope, so there are no surprises later.
• 3. Design. A clean, branded interface drawn around your actual flows, not dropped onto a template. We design for the small screen and for touch first, with real states — loading, empty, error — handled rather than ignored.
• 4. Build. We write the app and its backend in parallel: a React 19 + TypeScript app wrapped by Capacitor, on a Cloudflare Workers + Neon Postgres backend. You see working builds early and often, on a real device, not just in a slideshow.
• 5. Native polish. We wire the things that make an app feel native rather than a webpage in a frame: push notifications, splash and icons, offline behaviour, and the platform conventions iOS and Android each expect. This is the step a thin wrapper skips — and the one Apple's review notices.
• 6. Ship. Store accounts, code signing, privacy declarations, screenshots, and the submission to App Store and Google Play. With Klura's Apple Developer Program organisation enrollment, your app is published under your company's identity, and we handle the review back-and-forth.
• 7. Maintain. Apps aren't finished at launch — iOS and Android ship breaking OS updates every year. We keep it healthy with patches, fixes, and small improvements on a plan agreed up front.

What you get

A Klura app engagement is the whole product, not just a frontend. Depending on your scope, that typically includes:

• A native-feel iOS app and Android app built from one codebase — the same features, shipped to both stores, without paying to build everything twice.
• The backend behind it: accounts and authentication, a database, an API, and any admin view you need to run the thing — built on edge + serverless infrastructure that's near-free to run at small scale.
• The integrations your product actually needs — payments (Stripe), push notifications, maps, analytics, third-party APIs — wired and tested, not bolted on as an afterthought.
• Store submission handled end to end: developer accounts, signing, privacy and data declarations, screenshots, and the review process, with publication under Klura's Apple Developer organisation identity.
• Full ownership: the code is yours, the repository is yours, and one named senior person knows the whole system and is accountable for it.
• A maintenance arrangement so the app survives next year's OS releases — agreed openly, not left as a surprise invoice.

If your idea is genuinely web-first — a dashboard, a portal, an internal tool — we'll say so and point you at web-app development instead. We scope for what the product needs, not for what bills the most hours.

The stack, and why — native feel without building it twice

The biggest avoidable cost in app development is building the same app twice. Fully native means a separate iOS codebase in Swift and an Android codebase in Kotlin — two builds, two sets of bugs, two of everything to maintain. Swedish guides put native at roughly 40–80% more than cross-platform for the same scope.

Klura builds cross-platform with Capacitor wrapping a React 19 + TypeScript app. You write the app once and ship it to both the App Store and Google Play. Capacitor runs your interface in a native shell with full access to the device — camera, push notifications, secure storage, biometrics — so the result feels like a real app, not a website in a window, while you pay closer to the cost of one app than two. The same React + TypeScript code can also power a marketing site or a web dashboard, so a product and its web presence share one codebase instead of three.

Behind the app sits a lean, modern backend: Cloudflare Workers running TypeScript at the edge, with Neon Postgres as the database — TypeScript end to end, from the button a user taps to the row it writes. It scales with usage and is close to free to run when traffic is small, which keeps both build and running costs honest.

We'll be straight about the trade-off: there's a narrow set of products — heavy real-time graphics, frame-perfect games, deep platform-specific hardware work — where a true native build is genuinely the right call, and we'll tell you plainly when yours is one of them. For the large majority of apps, it isn't, and paying for two native codebases is paying twice for the same product.

The proof that this stack works isn't a slide — it's this page. klura.app itself runs on TanStack Start on Cloudflare Workers, the exact infrastructure we'd build your app's backend on. It's a working artifact you can inspect, not a claim you have to take on faith.

Honest pricing orientation

We don't publish a fixed price list, because an honest number depends on your scope and a made-up one helps nobody. What we can give you up front is a straight indicative range, and a fixed proposal once the scope is clear. As a reference point, senior Swedish developers invoice roughly 800–1 200 kr/hour, and a senior independent studio like Klura carries no agency markup, no account-management layer, and no junior-billed-as-senior — you pay for build hours, not a sales pipeline.

Roughly, a focused MVP — a handful of screens, login, one core feature and a light backend, shipped to both stores from one Capacitor codebase — tends to land in a low six-figure SEK band, while a multi-role app with payments and heavier integrations moves up from there. Rather than repeat numbers that go stale, we keep the detailed, dated cost ranges in one place: see what does an app cost for current 2026 Swedish-market bands for an MVP, a standard app, and a complex build, plus the running costs after launch.

One line founders most often miss: store accounts and maintenance. The Apple Developer Program is about 99 USD a year (the same for an organisation, which is how Klura is enrolled), Google Play is a one-time ~25 USD, and an app realistically needs roughly 15–20% of its build cost a year to stay healthy as iOS and Android ship their annual breaking updates. We name these up front so the budget you sign off on is the real one.

FAQ