Flutter vs React Native, Shared Logic and CI/CD Guide

Planning a Flutter or React Native build alongside an existing web product? The decisions around shared logic, design tokens, and CI/CD determine whether you actually save time.

Flutter vs React Native, Shared Logic and CI/CD Guide

Most cross-platform app projects do not fail because the framework was wrong. They fail because nobody decided, upfront, which parts of the existing web product could be shared and which needed to be rebuilt from scratch. A Flutter or React Native app build layered onto a mature web codebase can cut delivery time by 30% or more. It can also double your maintenance burden if the shared-logic boundaries are drawn badly. The difference comes down to three sets of decisions made before a single screen is designed.

Get a cross-platform delivery plan tailored to your existing web stack and mobile goals.

Talk to our engineering team

Why “cross-platform” does not automatically mean “cheaper”

The pitch is familiar: write once, run on iOS, Android, and (maybe) web. Flutter and React Native both deliver on that promise at the UI layer. But the UI layer is only one slice of what you maintain. Business logic, authentication flows, API contracts, design tokens, localisation strings, analytics events, and CI/CD pipelines all sit underneath. When your organisation already runs a web product with its own codebase, the question is not “which framework?” but “what do we share, and at what boundary?”

Getting that wrong creates two problems at once. Engineers duplicate validation rules or pricing logic in separate repos, so bugs ship on one platform and not the other. Designers maintain two token files that slowly drift, producing a subtly inconsistent brand. Both problems compound over time, and both are avoidable with the right architectural decisions in discovery.

The real cost of cross-platform is not the framework licence. It is the ongoing maintenance of every shared boundary you chose not to define at the start.

Deciding what logic to share (and what to keep separate)

Not all code should be shared. That sounds obvious, but the temptation to maximise reuse pulls teams toward a monorepo where everything lives together, or a set of shared packages that nobody owns. Both patterns can work. Both can also become a single point of failure for every platform release. The decision depends on the shape of your existing web product.

Start by mapping the categories:

The guiding principle: share the rules, not the rendering. If a piece of code answers the question “is this user allowed to do X?” it belongs in a shared layer. If it answers “how does this screen animate into view?” it does not.

1

Pure business logic:

Pricing calculations, eligibility checks, permission models. These are framework-agnostic and excellent candidates for a shared package. If your web product is in TypeScript, React Native can consume the same package directly. Flutter teams typically extract this logic into a Dart package or call it via a thin API layer.

2

API client and data models:

Schema definitions, serialisation, and error handling. Sharing these prevents the classic bug where the mobile app expects a field the API no longer returns. Tools like Buf for Protobuf or OpenAPI generators make this mechanical rather than manual.

3

UI components and interaction logic:

This is where sharing gets dangerous. A web modal and a mobile bottom sheet solve the same user problem but have entirely different interaction models. Forcing a shared component here usually produces a mediocre experience on both platforms.

4

Platform-specific integrations:

Push notifications, biometric auth, deep linking, camera access. These must remain native (or use well-maintained framework plugins). Do not abstract them behind a shared interface unless you have tested that interface against every OS version you support.

Design tokens: the bridge between your web and mobile design systems

A cross-platform design system is not a nice-to-have when you are shipping web and mobile simultaneously. It is the mechanism that prevents your design team from becoming a bottleneck on every release.

Design tokens are the atomic values: colours, spacing scales, typography sizes, border radii, elevation shadows. They are defined once, in a platform-agnostic format (typically JSON or YAML), and then transformed into platform-specific outputs. CSS custom properties for web. A Dart theme file for Flutter. A StyleDictionary-generated Swift or Kotlin file if you also maintain native modules.

The trap is partial adoption. If the web team hardcodes hex values while the mobile team consumes tokens, you get drift within weeks. The fix is a single source-of-truth repo for tokens, with automated transforms that run on every merge. Style Dictionary remains the most widely adopted tool for this pipeline, though alternatives like Specify and Tokens Studio have matured considerably.

One decision that catches teams off guard: responsive breakpoints. Your web product has them. Your mobile app mostly does not need them, because the OS handles orientation and safe areas differently. Mapping web breakpoints directly to mobile layouts produces padding that looks wrong on smaller screens. Define separate spatial token sets for mobile, derived from the same base scale but tuned for touch targets and native navigation chrome.

How CI/CD pipelines make or break the economics

A cross-platform project that saves 40% on development but doubles the time spent on build, test, and release will not look like a win on a spreadsheet. CI/CD is where the economics of shared code either pay off or collapse.

When you already have a web product, you already have a deployment pipeline. Adding a mobile build means adding platform-specific runners (macOS for iOS builds), code signing, app store submission, beta distribution, and potentially over-the-air update tooling like CodePush (React Native) or Shorebird (Flutter). Each of these has configuration overhead and ongoing maintenance cost.

The decisions that matter most:

The fastest cross-platform teams are not the ones with the most shared code. They are the ones whose CI pipeline can tell, in under ten minutes, exactly which platforms a given change affects.

1

Monorepo vs. polyrepo:

A monorepo (using Nx, Turborepo, or Melos for Flutter) lets you run a single CI pipeline that builds, tests, and deploys all platforms from one commit. This is powerful for shared-logic changes. But it also means a change to a web-only utility can trigger a full mobile build if your dependency graph is not correctly scoped. Invest in affected-target detection early.

2

Test strategy across platforms:

Unit tests for shared logic run once, regardless of platform. That is the dividend. Integration and end-to-end tests, however, must run per platform. Budget for platform-specific test infrastructure. Detox for React Native, integration_test for Flutter, Playwright or Cypress for web. Do not assume that passing on one platform means passing on all.

3

Release cadence alignment:

Web can ship multiple times per day. Mobile releases go through store review, which takes hours to days. If your shared logic package bumps a version, both platforms need to release. Decide upfront whether you decouple release trains (safer, more overhead) or couple them (faster iteration, higher coordination cost).

The org-design question nobody asks early enough

Technical architecture mirrors organisational structure. If your web engineers and mobile engineers sit in separate teams with separate backlogs, shared packages will rot. Nobody will own the boundary, and every cross-platform change will require a coordination meeting that could have been a pull request.

The pattern that works: a platform team (two to four engineers) owns the shared logic layer, the design token pipeline, and the CI/CD infrastructure. Product squads consume those shared packages and own the platform-specific UI and integration code. This mirrors how native mobile builds are typically structured, with a clear separation between platform concerns and product concerns.

If your organisation cannot staff a dedicated platform team, consider whether cross-platform is actually the right strategy. A single React Native or Flutter codebase maintained by one squad, with no shared web logic, can still be the right call. It just produces a different (and smaller) set of savings.

Choosing between Flutter and React Native when web is already React

This is the most common scenario we see: the web product runs React (or Next.js), and the team asks whether React Native is the obvious choice because the name matches.

It is not that simple. React Native shares React’s component model and JavaScript/TypeScript ecosystem, which means your web engineers can read and write mobile code with a shorter ramp-up. Shared business logic packages work natively. The developer experience is familiar.

Flutter uses Dart, a different language entirely. That means your web engineers need to learn a new syntax, and shared logic must either live in a language-agnostic API layer or be duplicated. However, Flutter’s rendering engine (Impeller, as of recent releases) is entirely self-contained, which means fewer platform-specific visual bugs and more predictable animation performance. For teams building heavily branded, animation-rich products, that trade-off can be worth the learning curve.

The deciding factor is usually the shared-logic question from the section above. If you have substantial TypeScript business logic that you want to reuse without an API hop, React Native has a structural advantage. If your logic already lives in backend services and the mobile app is primarily a presentation layer, Flutter’s rendering consistency becomes more valuable. When evaluating the development cost, factor in ramp-up time for your existing team, not just per-feature velocity in isolation.

A practical pre-build checklist

Before you write a line of mobile code, answer these questions with your engineering and design leads:

If you are also rethinking the app’s user experience during this build, aligning your onboarding flow with the web product’s existing patterns is one of the highest-leverage design decisions you will make.

Cross-platform delivery saves time when the boundaries are drawn correctly and the pipeline supports them. It costs more when those decisions are deferred to “later.” Later, in software, usually means “after the first painful production incident.”

1

Inventory shared logic:

List every business rule, validation, and calculation in your web codebase. Score each for reuse feasibility (language compatibility, dependency weight, test coverage).

2

Audit your design tokens:

Are your web design values already tokenised? If not, budget a sprint to extract and normalise them before mobile work begins.

3

Map your CI/CD gap:

Document what your current pipeline does. List every capability you will need to add for mobile (code signing, store submission, beta distribution, device-farm testing).

4

Define ownership:

Assign a team or individual to own the shared layer. If you cannot name that person today, resolve this before kickoff.

5

Set a release cadence policy:

Decide whether web and mobile release independently or together, and document the rules for shared-package version bumps.

FAQs

Can I share React components directly between my web app and React Native?

Not directly. React DOM components render to HTML elements, while React Native components render to native views. You can share business logic, hooks, state management, and API clients written in TypeScript. UI components must be written separately for each platform, though they can follow the same design token system for visual consistency.

Is Flutter a good choice if my team only knows JavaScript?

Flutter requires learning Dart, which has a moderate learning curve for JavaScript developers. Most teams report productive Dart fluency within two to four weeks. The bigger consideration is whether you need to share TypeScript business logic directly with your web app. If that logic lives in backend APIs rather than the frontend, Dart’s learning curve becomes a manageable trade-off.

How do I keep design tokens in sync across web and mobile?

Use a single source-of-truth file (JSON or YAML) stored in its own repository or package. Run automated transforms on every merge using a tool like Style Dictionary to generate platform-specific outputs: CSS custom properties for web, Dart theme files for Flutter, or native resource files for React Native. Block merges that introduce hardcoded values outside the token system.

Should I use a monorepo for web and mobile code?

A monorepo simplifies dependency management and makes cross-platform changes atomic. It works well when you invest in affected-target detection so that web-only changes do not trigger full mobile builds. If your CI infrastructure cannot support selective builds, a polyrepo with shared packages published to a private registry is a more pragmatic starting point.

What is the biggest risk of adding a mobile app to an existing web product?

Maintenance divergence. Without clear ownership of the shared logic layer and a CI pipeline that tests all platforms on every relevant change, business rules and visual styles drift between web and mobile within months. The fix is organisational (dedicated platform ownership) as much as it is technical.

Plan your cross-platform build on solid ground

The shared-logic, design token, and CI/CD decisions covered here are exactly what we scope during discovery. We help teams ship Flutter and React Native apps that integrate cleanly with existing web products, not replace them.

Book a discovery session