iOS · ANDROID · FIELD TEAMS
Mobile applications for businesses
We build custom mobile apps for iOS and Android, for your company's customers or for your field team. We choose the technology after an analysis, to fit the app's business goal. Publishing in the App Store and Google Play is included in the project price.
Publishing
iOS + Android
App Store and Google Play in the project price, not as an extra
// THREE TYPES OF PROJECTS
Three types of mobile projects we implement
Mobile application as main product, mobile extension of existing system or a field application for operational teams. Each type has a different logic design - and a different post-discovery stack.
MEDIUM–HIGH COMPLEXITY · 2–9 MONTHS
Mobile application as the main product
The mobile app is the main point of contact with the end user. B2B SaaS where the PC version doesn't make sense, an industry-specific product (logistics, healthcare, field sales), a serious B2C product with a specific business case.
Stack individually - native or cross-platform.
LOW–MEDIUM COMPLEXITY · 2–6 MONTHS
Mobile extension of the existing system
Mobile app as part of broader client ecosystem - complementing web product, adding mobile access to existing backend, cross-platform with website. Typically React Native, but stack individually.
HIGH COMPLEXITY · 4–9 MONTHS
B2B field/operational application
Workers in the field - service, audits, deliveries, installations, mobile sales. Offline-first synchronization, enterprise-class MDM, ERP/CRM integrations, kiosk mode. Often native Android dominates (Samsung/Xiaomi MDM).
STACK AFTER ANALYSIS
Native or cross-platform — we choose the technology after an analysis
Native iOS, native Android, React Native or a hybrid: the decision is based on the business goal, technical criteria and long-term cost. The analysis ends with an architecture decision record (ADR) with the chosen technology and the reasons.
Swift + SwiftUI
Native iOS
We choose it when
- High performance is needed (camera ML, ARKit, audio DSP)
- The app relies deeply on the Apple ecosystem (HealthKit, on-device CoreML, WidgetKit)
- iOS-only features are needed (App Clips, Live Activities, watchOS, Vision Pro)
- The client has its own Swift team
Tools: Xcode, Swift, SwiftUI, Combine.
Long-term cost: higher, because it needs a separate team.
Kotlin + Compose
Native Android
We choose it when
- Android-only features are needed (Samsung and Xiaomi MDM, Wear OS, Android Auto)
- The industry runs mainly on Android (public sector, medical field teams)
- High performance in the Android ecosystem is needed
- The client has its own Kotlin team
Tools: Android Studio, Kotlin, Jetpack Compose, Coroutines.
Long-term cost: higher, because it needs a separate team.
RN + Expo
React Native
We choose it when
- One team should cover two platforms
- Time to market matters
- About 80% shared features on iOS and Android is enough
- The client already uses React in a web app and wants shared team knowledge
Tools: React Native, Expo, TypeScript, EAS Build and Submit.
Long-term cost: lower, one team.
RN + native modules
Hybrid
We choose it when
- 80–90% of the scope is standard and 10–20% needs high performance
What it looks like
- React Native with Swift and Kotlin modules for camera processing, audio DSP and system integrations
- React Native delivery time, native performance where it is needed
Tools: React Native with Swift and Kotlin modules, EAS bare workflow.
Long-term cost: medium, React Native with selected native parts.
NEXT.JS · PAYLOAD · POSTGRESQL
Backend depending on the case
We choose the backend after an analysis too, not in advance.
Most often it is Next.js, Payload CMS and PostgreSQL. If you already have a web application, one team covers both and the long-term cost is lower.
Another technology when it serves the goal better
- Event-driven microservices: scaling independent domains
- Spring Boot / JVM: a Java ecosystem, banking integrations, enterprise ERP
- Python: data processing, ML / AI model inference
- PHP (Symfony, Laravel): an existing client system to maintain
We record the decision in an ADR with the reasons.
REST · GraphQL · gRPC
Integration with your backend
We choose it when
- You already have a working backend or system the app should use
- Rebuilding the backend is not needed
What it looks like
- The app connects to your API (REST, GraphQL, gRPC)
- The backend stays as it is
Long-term cost: depends on your system; the app does not add a second backend.
FAQ
Why not Flutter?
Discipline stable stack. React Native has more than 5 years of production experience (Meta, Microsoft, Shopify, Discord), a larger team of specialists in Poland and better integration with our React/Next.js stack.
Flutter requires a separate Dart ecosystem, Google is the only sponsor, and the Polish specialist market is smaller.
Is the technology decided after the analysis?
Yes. The analysis (a paid stage with a deliverable) ends with an architecture decision record (ADR) with the chosen technology and the reasons. You get the selection criteria in writing and can take them to another vendor.
WHEN THE MOBILE APPLICATION
Mobile app, PWA or responsive website - which achieves the business goal
Some of the "we want a mobile app" conversations end with the decision that a PWA or website responsive achieves the business goal cheaper and faster. This is a result of Discovery, not an initial thesis.
Native
A mobile app makes sense when
Critical device APIs (camera, GPS, biometrics, NFC) Complex offline-first synchronization Push notifications required for business (not nice-to-have) Store presence required for business (B2B SaaS, B2C product) Enterprise MDM (device management for field application) High performance (real-time data, image processing)
PWA
A Progressive Web Application will suffice when
Flow equivalent to a web page (same operations as a browser) No critical device APIsPush web is enough (Push API, iOS limitations) User has occasional sessions Add-to-Homescreen as sufficient "application experience"
Website
A responsive website is enough when
Main path on computer, mobile = supplemental User returns via search engine / link, not shortcut No push, no offline, no device APIBusiness objective pursued by the website/web application Discovery shows that in-store presence does not add value
OUT OF SCOPE
What we don't do
We do not take on
- Games or AR and VR apps
- Small apps without an analysis, which a freelancer will do faster
- Apps when a PWA or a website serves the goal better — then we say so plainly
// PROCESS
Six stages from brief to production
dvnt process standard - Discovery as a paid stage with a result, 2-week sprints, in-store publication in the price of the project, three options for cooperation after stabilization.
1-3 weeks, PLN 5-15k
Discovery
Audit of the business problem and objective.
Stack decision (native iOS / native Android / React Native / hybrid) with justification. Scope per platform, integrations, offline mode strategy.
Business brief + ADR + final quote + schedule. Client can go with documentation to another developer.
2-4 weeks
Graphic design and UX
Figma, mobile patterns (iOS HIG + Material Design 3), interactive prototype for 3-5 key paths. Mobile system design - typography, spacing, platform-aware components.
Design system + interactive prototype + store materials
6-24 weeks (depending on the scope of the project)
Implementation
Sprints 2 weeks, demo per sprint. Code in client repository from day 1 of EAS Build / Xcode Cloud / Gradle CI depending on stack. TestFlight + Play Internal for client on an ongoing basis.
A working application in a test environment
2-4 weeks
QA on real devices
Test matrix - the two latest iOS versions (3-5 models), the three latest Android versions (4-6 models of Samsung / Xiaomi / Pixel brands), different networks (3G/4G/WiFi/offline), different languages. Not just an emulator.
QA report + list of errors resolved per device
1-3 weeks
App Store and Google Play publication
Account setup (if the customer does not have one), store materials (screenshots, description, icons, privacy policy URL), submission, Apple verification response (often 1-2 rounds), first production version.
App in the App Store and Google Play
4-12 weeks after implementation
Stabilization + three cooperation options
Three options after stabilization:
Internally - documentation, ADR, customer team training, dvnt output Subscription - maintenance + new features, hourly or fixed monthly rate Strategic cooperation - dvnt as product co-owner, retainer + SLA
Stable production + cooperation model decision
PUBLICATION IN STORES
App Store and Google Play included in the project price
Publication in stores is a standard part of the process - not an additional item in the price list. Developer accounts remain with the customer (the company must be the publisher of its own application).
dvnt
What we do on the dvnt side
Setting up developer accounts (App Store Connect, Google Play Console) Preparation of store materials - screenshots per device, description (PL/EN), app icon, privacy policy URLNotification for verification at both stores Response to Apple's verification - often 1-2 rounds of fixes after Apple's feedback First production version on the App Store and Google PlayConfiguration of TestFlight + Google Play Internal Testing for the customer during the project
customer
What's on the client side
Apple Developer Program - $99 / year (corporate account subscription) Google Play Developer - $25 one-time fee (account registration)URL of the application privacy policy on the customer's domain Brand materials - logo, colors, store marketing materialsDUNS number for your Apple corporate account (if you don't already have one)
PRICING · 3 VARIANTS
What a mobile app costs
The prices below are a starting point. On a call we advise what really has to go into the app and look for the solution that suits your company best. You get the final quote once the scope is agreed.
BASIC · 2–3 MONTHS
from PLN 40,000
For whom: a companion app, a simple B2B MVP or an internal tool.
MOBILE PRODUCT · 4–6 MONTHS
from PLN 80,000
For whom: your own mobile product, a SaaS for businesses or an app for a field team.
EXTENDED · 6–9 MONTHS
from PLN 150,000
For whom: large field operations, business-critical apps and regulated industries.
What drives the price
- Technology: React Native for both platforms, native for one or both, or hybrid
- Offline work: a simple cache or full synchronisation
- Backend: ours, your existing one or built from scratch
- Legal requirements: basic, or GDPR and industry rules (healthcare, finance)
// HOW WE WORK
Six principles of cooperation
The work discipline we apply to every mobile project - regardless of regardless of the client's stack, scope and industry.
Technology
Stack under business purpose, not technology fashion
Native iOS, native Android, React Native or hybrid - a decision in Discovery based on business and technical criteria. No default "RN because it's faster" or "native because it's better."
Publication
App Store and Google Play included in the project price
Publishing to stores is a standard part of the process, not an additional item on the price list. Developer accounts on the client side (you must be the publisher of your own app), the rest on the dvnt side.
Build vs buy
Mobile app vs PWA - the choice after Discovery
Some of the "we want a mobile app" conversations end with the decision that PWA achieves the business goal cheaper and faster. We say it outright if Discovery shows it.
Discovery
Discovery as paid stage with result
Discovery (5-15k) is a paid stage with specific deliverables - brief, ADR, final pricing, schedule. The client can go with the documentation to another developer - it's a discipline, not a trap.
Stability
Stable stack, no fashion-driven libraries
Each library in production has a minimum of 5 years of production experience. No experimentation on live customer project. List of technical decisions (ADR) with justification for each.
Collaboration
Three options after stabilization + code in customer repository from day 1
After implementation, three paths - in-house, subscription, strategic cooperation. Code in the customer's repository from the first sprint, zero dependence on the vendor. Full documentation and ADR as standard.
FAQ
The most common questions about mobile apps
The questions we get most often in Discovery. A full FAQ of the development of software (15+ questions in 7 groups) will be published in a separate section.
Native iOS/Android or React Native - which to choose?
This is a Discovery decision, not an initial thesis. Native (Swift, Kotlin) is chosen when performance-intensive features are needed (camera ML, AR, audio DSP), platform-specific APIs (HealthKit, enterprise MDM) or deep integration into the ecosystem. React Native when the priority of deployment time, one team for two platforms and ~80% feature parity is enough. Hybrid (RN + native modules) when 90% of scope is standard and 10% requires native performance.
Is publication in the App Store and Google Play included in the price of the project?
Yes - account setup, screenshots, store description, submission, response to Apple verification, first production version. On the customer side, developer accounts remain: Apple Developer $99/year and Google Play $25 one-time. Post-deployment updates are outside the project - subscription or hourly.
How long does the process take from the brief to the first version in the store?
- Basic application (Level 1) - 2-3 months.
- Mobile product / field application (Level 2) - 4-6 months.
- Expanded / corporate (Level 3) - 6-9 months.
- Apple verification adds 1-7 days, sometimes a round of revisions.
- Discovery (1-3 weeks) we add with separate pricing.
What about updates and maintenance after publication?
Three options after stabilization. In-house - we provide the documentation, ADR and training, the client carries on alone. Subscription - maintenance and new features hourly or fixed monthly rate. Strategic cooperation - dvnt as co-owner of the product with fixed contract and SLA. Choice individually, most often the decision falls 4-12 weeks after implementation.
Do we have to use your backend, or will you plug into ours?
Both scenarios. Design from scratch - default dvnt stack: Next.js + Payload CMS + PostgreSQL (consistent with web applications). Integration with existing client backend - REST, GraphQL or gRPC, individually. Decision in Discovery, based on what you already have and what the long-term goal is.
START
Is the brief ready? Let's talk
Discovery is a concrete step with an outcome - ADR, final pricing and schedule. Every client starts with the same conversation, regardless of the scope of the project.
RESOURCES · BEFORE WE TALK
Before we talk
ARTICLE
How to make a mobile app for your business — from choosing a platform to publishing it
How to make a mobile app for a business: Android vs iOS in Poland, native or cross-platform, a DUNS number, closed testing and app review.
ARTICLE
Flutter vs React Native — which to choose for a business app, and when to stay native
Flutter vs React Native: how they differ, what they cost in Polish quotes, what Apple and Google force you to update every year, and when native is better.
REPORT
Mobile application costs in Poland — 2026 edition
The 2026 edition: 116 price observations from 60 Polish companies.
// Next step
Describe your project. We reply within 24 h.
A few sentences are enough: what should work, what it connects to and by when. No brief, no commitment.
What happens next
- We read your message and reply within one working day.
- We set up a short call about the scope, with no sales pitch.
- You get proposed stages and a price range.
Other areas that may be relevant
See web applications
A companion web application?
Often a mobile app is part of a broader system - a web product, admin panel, dashboard.
Back to the hub
All areas of software development
dvnt software development hub - seven categories, architecture decision, scope discipline.