Mobile app agency — iOS, Android and React Native. But do you really need an app?
iOS & ANDROID · REACT NATIVE · UI/UX · ASO
TasarımMania is a mobile app agency with an eight-person team and 14 years behind it, building native apps for iOS and Android and cross-platform apps with React Native; delivery takes 8–16 weeks, and the source code and store accounts stay yours.
↑ PRESS ONE OF THE TWO — ITS COUNTERPART LIGHTS UP IN THE STORE LAYER
├ screens / components
├ shared API — same as the web
└ build → two stores
- purchase
- notification_permission
- sign_up
Store statistics and in-app events on one dashboard.
The app, the code and the store are set up at the same time; measurement isn't bolted on later.
typical delivery time
settled in the quote
in web and software
store accounts
First, this question: do you really need an app?
Mobile apps are the module with the least proof in our portfolio — we're not hiding that. The question to ask before commissioning an app is this: does the user want something specific to the phone, like the camera, notifications or offline use, or do they just want quick access to information from a mobile? If it's the second, the answer may be a PWA (a web app that can be added to the phone, with no store involved); it's far cheaper, live within weeks, and doesn't wait on store approval. If you need the camera, location tracking, offline working or visibility in the stores, a real app is the right call.
What this service covers: native, React Native, interface and marketing
Before deciding whether to write your app natively or cross-platform, we settle the scope: the four areas of expertise are below.
iOS and Android (Native)
Platform-specific apps with the highest performance, built with Swift and Kotlin; the right choice for work needing the camera, sensors or heavy graphics.
- Native development with Swift (iOS) and Kotlin (Android)
- Full access to device hardware (camera, sensors, Bluetooth)
- Platform-specific design language (Human Interface / Material)
- Push notifications and background services
React Native (Cross-Platform)
Both iOS and Android from one codebase; the faster, more economical route for most commercial apps.
- Release to two platforms from one codebase
- Near-native performance, shorter development time
- A shared API with your website
- Send an update to both stores in one go
Interface Design (UI/UX)
Screen flow, button placement and the colour system don't get coded until they've been through user testing.
- User flow and wireframes
- High-resolution screen designs (Figma)
- In-app icons and visual language
- Accessibility and touch target standards
Marketing (ASO and Store Optimization)
The work doesn't end when the app is published; being found and downloaded in the store is a separate job. The gate to release is the store's own rules; the App Store review guidelines list the reasons for rejection.
- App Store / Google Play keyword optimization
- Store graphics and preview video
- Download campaigns with Google Ads / Meta
- Download and retention measurement
Let's work out which scope suits you, togetherFive steps, two minutes. The timeline and price range appear on screen.
Mobile app costs in 2026: what sets the band?
We don't have a single rate card; on every project the band is set by the scope . VAT is stated in the quote; one codebase with React Native usually works out cheaper than native. Five things set the band:
- The number of platforms: one, or both iOS and Android
- Whether native or React Native is chosen
- The number of screens and how complex the flows are
- The backend, API and third-party integration requirement
- Whether the design is ready (is there a Figma file)
Sometimes the right answer isn't even an app — we explained why above. We start the conversation by mapping the scope.
What's included, what isn't
Included in the price
- Interface design (UI/UX) and user flow
- iOS and/or Android development
- Backend and API integration (where it's in scope)
- The App Store and Google Play release process
- Push notification infrastructure setup
- Device and operating system testing
- 30 days of correction support after launch
- Source code and technical documentation
Separate line item
- Apple Developer (annual) and Google Play (one-off) account fees
- Store advertising budget (ASO / Google Ads campaigns)
- Monthly maintenance and operating system update package
- Store commission on the in-app payment system
- Scope changes requested after delivery
See your project's band on screenOnly your name and phone number are required.
Native or React Native — we don't impose a technology on you
Either route can be right; which one depends on your use case. We don't describe the difference — we write down which one wins for which job.
Platform-specific, highest performance
- A separate codebase for each platform; higher development and maintenance costs.
- Each update is prepared separately for each store.
- The right choice for camera, sensor, Bluetooth and heavy graphics work.
One codebase, two stores
- Release to both iOS and Android from one codebase; development time comes down.
- A shared API with the website; near-native performance on forms, lists and content flows.
- More economical and perfectly adequate for most standard commercial apps.
Frequently asked questions: mobile app costs, process and ownership
The questions that come up most, with short answers. Where the detail sits in another section, there's a link at the end of the answer.
How is the price of a mobile app worked out, and what moves it in 2026?
The price is set by the number of platforms (one or both), the number of screens, the backend requirement and third-party integrations; there's no single fixed price and we don't publish a rate card either.
In the quote wizard we map the scope together, and you see the band and the estimated timeline on screen; we don't sell fixed packages.
What stages does mobile app development go through, and how long does it take?
The process runs through discovery, interface design, development, testing and store release; the total takes between 8 and 16 weeks depending on the size of the scope, and we don't quote an exact number of days.
We work stage by stage rather than week by week, and we don't move to the next stage until the current one is signed off; we've set out the detail in the process section.
Should I choose React Native or native (Swift/Kotlin)?
For most commercial apps React Native is enough and more economical; for work that needs the camera, sensors, heavy graphics or deep hardware access we go native (Swift/Kotlin).
Once we've seen the scope we decide together which technology suits you — we don't impose one on you.
How does the app get onto the App Store and Google Play, and is there a risk of rejection?
Yes, both stores have a review process; Apple usually takes a few days, Google Play anywhere from a few hours to a few days, and being rejected on the first submission is normal.
We fix the reason for the rejection and resubmit, and that revision is included in the price; we've written up the detail in the store release section.
Couldn't I use a no-code tool or a PWA instead?
In some cases, yes: if it's mainly about displaying content and you don't need the camera or offline use, a PWA (a web app added to the phone, with no store involved) is a much cheaper and faster answer.
If you need the camera, location, offline use or visibility in the stores, a real app is the right call; we've set out the difference honestly above.
How are in-app purchases and subscriptions set up?
Through Apple's and Google's own payment infrastructure; on digital goods and subscriptions the store commission is deducted automatically.
For physical goods or services there's no such requirement, and external payment systems can be used; we settle which model fits you in the scoping call.
Who maintains and updates the app after it's published?
Thirty days of correction support after launch is included in the price; after that, a monthly maintenance package keeps track of operating system updates and changes to store rules.
iOS and Android release a new version every year, and regular testing and updates are needed to stay compatible.
Who owns the source code and the store accounts?
The source code is yours and is handed over; the Apple Developer and Google Play accounts are opened in your name from the start, not ours.
If you stop working with us, your app can carry on with another team; we've written up the detail in the ownership section.
Other modules
Web Design & Software The ground the other four modules stand on. Meta & Google Ads The accounts are in your name; we build the pages the ads land on. Video Production Ad, Reels and product video from a single shoot. SEO Services Technical SEO, content and local visibility.If you'd like to look before deciding
The process, store release, life after delivery and ownership — all here. Open it, read it, close it.
The process: how we get from discovery to store release
We don't give an exact number of weeks because the scope differs on every project; the flow is fixed: first discovery and a list of screens, then sign-off on the interface design, then development begins. Once development is finished, the testing stage runs through device and operating system combinations, and finally the store release happens. Each stage starts after the previous one is signed off — nothing is skipped; the total stays in the 8–16 week band.
The store release process: App Store and Google Play approval
The two stores work to different rules. A Google Play review usually comes back within a few hours to a few days; Apple's App Store review is stricter and can take several days. Being rejected on the first submission is normal — a missing privacy statement, no test account supplied, or screenshots that don't match. If it's rejected we fix the reason and resubmit; that revision process carries no extra charge.
After delivery: updates, maintenance and version compatibility
The work doesn't end at launch. Apple and Google release a new operating system version every year; after a while an app can fall out of step with older APIs and get a warning that it will be removed from the store. Thirty days of correction support after launch is included in the price; after that, a monthly maintenance package keeps track of version compatibility, security patches and small bug fixes. On apps without maintenance, that risk builds up over time.
Ownership: who holds the source code and the store accounts
The Apple Developer and Google Play Console accounts are opened from the start in your name, with your email address; we're added as administrators, not owners. When the project finishes, the source code repository and the technical documentation are handed over to you. Those two rules are what make your monthly exit right real: if you stop working with us, your app can carry on with another team without a hitch.
Native or React Native: how the decision is made
For apps needing the camera, Bluetooth, heavy graphics or deep hardware access, native (Swift/Kotlin) runs more reliably. A standard commercial app — forms, lists, notifications, straightforward content — goes out to both iOS and Android from one React Native codebase; development time and cost come down. We make the decision together in the first discovery call, and we don't impose a technology on you.
iOS · Android · React Native
If you've decided you really do need an app
Let's map the scope together; see the timeline and budget band on screen in the five-step quote wizard, or just message us on WhatsApp.