Skip to content
dvnt.io

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. 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. 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

  3. 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

  4. 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

  5. 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

  6. 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

// 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

  1. We read your message and reply within one working day.
  2. We set up a short call about the scope, with no sales pitch.
  3. You get proposed stages and a price range.
Meeting date (optional)

Time

CET

Checking free times…

Budget (net)

By sending this form, you accept the Privacy Policy.

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.