iOS and Android — native or cross-platform, driven by business decision
Native iOS (Swift) and Android (Kotlin) plus React Native cross-platform development. Build and deployment via Fastlane + CI/CD, full App Store and Google Play release support. Backend integration over REST or GraphQL.
Business context
Problems we solve
Typical situations where it's worth talking to us. If more than one rings a bell, we can probably help.
- P01
Web apps awkward on mobile
Clients want to use it on phone, but the web UI isn't touch-first. No push, no offline, no App Store presence. Native or cross-platform mobile delivers the right UX.
- P02
Native development expensive and slow for both platforms
Swift for iOS, Kotlin for Android — two code bases, two teams, two release cycles. React Native cross-platform gives 60–80% code sharing, with native modules where needed.
- P03
Cross-platform solutions have limits
React Native or Flutter promise the same code everywhere. Advanced features (in-app purchase, share extension, widgets) still need platform-specific integration. We know when to fall back to native.
- P04
App Store and Play Store deployment is complex
Apple Developer Program, code signing, App Store Connect, screenshot generation per size, review process. Easy to lose 2–3 weeks without preparation. Fastlane + documented submission checklist.
Deliverables
What we ship
Concrete deliverables, not abstract capabilities. Documentation and handover included with every shipment.
React Native cross-platform apps
Expo or bare React Native, TypeScript, React Navigation, Redux Toolkit or Zustand. Native module integration as needed (camera, NFC, Bluetooth). OTA updates via Expo EAS Update.
- React Native
- Expo
- TypeScript
- EAS
Native iOS (Swift)
SwiftUI or UIKit, Combine framework, Swift Concurrency, Xcode 16+. In-app purchase, push, widget extension, share extension. TestFlight beta distribution.
- Swift
- SwiftUI
- Xcode
- TestFlight
Native Android (Kotlin)
Jetpack Compose, Kotlin Coroutines, Hilt DI, Android Studio. Material 3 design. Google Play Internal Testing for beta.
- Kotlin
- Jetpack Compose
- Hilt
Backend integration over REST/GraphQL
API-first development: backend and frontend work in parallel against an OpenAPI or GraphQL schema. Auth (JWT, OAuth), file upload, push (FCM or APNs).
- REST
- GraphQL
- Firebase
- JWT
CI/CD, store submission and rollout
Fastlane pipeline for build and deploy, GitHub Actions triggers. Automated screenshot generation per size. Submission checklist, review feedback handling. Phased rollout with crash analytics.
- Fastlane
- GitHub Actions
- Phased rollout
Output
What you receive at the end
Go-live is not the end, it's a handover. You receive every artifact below, and your team can work with all of them.
- D01
iOS and Android build artifacts
Signed IPA and AAB files ready for App Store Connect and Play Console upload. Test and production builds clearly separated.
- D02
TestFlight and Internal Testing setup
Beta tester invite flow, build naming convention, release notes template. Your QA team can test independently.
- D03
Crashlytics and analytics
Firebase Crashlytics or Sentry, event logging on key user flows, retention dashboard baseline.
- D04
App Store and Play Store metadata
Title, description, screenshots per size, video preview (if needed), promotional text. Localization in HU + EN minimum.
- D05
Code signing certs and profiles
Apple Developer Program team setup, Play Store key generation, documented certificate storage and rotation.
- D06
Build pipeline (Fastlane + CI)
Automated build, version bump, signing, store upload. PR-merge to beta in 1–2 hours.
- D07
Release runbook + crash protocol
Step-by-step release procedure, rollback path (Google Play halted release, Apple expedited review).
Process
How we work
Six steps from discovery to support. The domain-specific content is tailored per project type.
- 01
Discovery
Platform strategy, feature scope, App Store / Play Store requirements, monetization model.
- 02
Design
User flow, native or React Native UI, Figma prototype, per-platform design system.
- 03
Build
Swift / Kotlin / React Native, CI/CD pipeline (Fastlane), beta build (TestFlight / Internal Testing).
- 04
Test
Unit test (XCTest / JUnit), UI test, manual QA, beta user feedback, crash analytics.
- 05
Launch
App Store and Google Play submission, screenshot and metadata, review management, gradual rollout.
- 06
Support
Crash analytics, OS update tracking, new feature releases, store rating management.
Architecture
Typical architecture
Typical native or hybrid mobile architecture: thin client, shared API Gateway, decoupled backend services.
Client
Gateway
Backend
Data
The native or cross-platform mobile app holds the user-facing logic (UI, state, local cache). The real business logic lives on the backend; the app presents and reacts to user actions.
The mobile API gateway (often shared with the web API) provides auth, rate limiting and push connectivity. The backend services (auth, payment, content) are independent and swappable.
Stack
Stack and tooling
Proven, documented tools. When the project justifies it we deviate — but we always explain why.
Cross-platform
- React Native
- Expo
- TypeScript
Native iOS / Android
- Swift
- Kotlin
Backend and integration
- GraphQL
- Firebase
- Node.js
- REST API
DevOps and deployment
- Fastlane
- Docker
Integrations
Integrations and touch points
Typical mobile app integrations for push, payment, analytics and auth.
- Firebase
- OneSignal
- Stripe Mobile
- Apple Pay
- Google Pay
- Sentry
- Crashlytics
- Mixpanel
- RevenueCat
- Auth0
- Branch
- Adjust
Timeline
Typical project timeline in weeks
A simple cross-platform MVP 8–10 weeks. Native for both platforms with MVP 12–16 weeks. Complex apps with payment + offline + push: 16–24 weeks.
- W1-2
Discovery
Platform strategy (native/cross), feature scope, monetization model, store requirements.
- W3-5
Design
User flow, Figma prototype, native-specific UI patterns, design system per platform.
- W6-12
Build
Sprint-based development, bi-weekly TestFlight / Internal Testing releases, code review.
- W13-14
QA + Beta
Cross-device testing, beta user feedback, crash analytics cleanup.
- W15-16
Launch
Store submission, review process, phased rollout, post-launch monitoring.
Limits
What we don't do
It's more honest to clarify upfront. Some kinds of work we intentionally don't take on — either it's not our profile, or we can't ship it at the quality we'd put our name on.
Game development isn't our profile
Unity or Unreal-based games need dedicated team expertise. We're strong on business apps (productivity, e-commerce, healthcare).
AR/VR isn't our core competency
ARKit, ARCore or VR-headset projects are a different specialty. We can support as a partner, but we won't take full responsibility.
We don't work with hybrid frameworks (Ionic, Cordova)
Our experience in 2026 is that the UX is weaker than React Native or native. We push toward React Native or native.
Pure white-label rebranding isn't for us
If the work is a finished app and only the logo and colors change, dedicated white-label platforms are cheaper.
First week
What to expect in the first 5 working days
The first week is about the platform decision and store readiness.
- 01
Monday
Kickoff + platform workshop
Native vs cross-platform matrix, monetization, target audience, success metric.
- 02
Tuesday
Feature scope
MoSCoW prioritization, MVP scope, post-launch roadmap outline.
- 03
Wednesday
Design audit
Brand assets, design system mobile specifics, accessibility requirements.
- 04
Thursday
Store and billing audit
Apple Developer and Google Play accounts, Stripe/Apple Pay/Google Pay setup, IAP plan.
- 05
Friday
Roadmap presentation
Sprint plan, milestones, release strategy, decision points.
Pricing
Pricing models
Three engagement models. Each one comes with a precise scope after discovery — concrete numbers follow once we've seen the project.
Fixed scope
MVP scope at fixed price, fixed deadline. New features go through a change request. Clear scope document before sign-off.
Ideal when
MVPs, B2C apps with a simple feature set, dedicated business cases.
Time & material
Sprint-based iteration. Continuous development against a roadmap where the next 3–6 sprints are refreshed regularly.
Ideal when
Product-style development where scope evolves with user feedback.
Retainer
Monthly fixed capacity for post-launch maintenance: crash fixes, OS update tracking, minor feature work, store rating management.
Ideal when
Maintaining production mobile apps, smaller feature iterations, OS version tracking.
FAQ
Frequently asked questions
Next step
Let's talk about your project
Concrete scope, transparent pricing, documented delivery. The first 30-minute call is free, and after NDA we share concrete numbers.