Case Study: JourneyApps Reduces Development Time by 10.8X

Industrial companies build powerful business apps on JourneyApps, either through using internal development teams or through outsourcing to their existing software development vendors or JourneyApps implementation partners.

Development teams choose JourneyApps because of the vast productivity gains over open-source software development frameworks such as Flutter, Swift (for iOS), Kotlin (for Android), and .NET (for Windows).

This case study follows the story of a multinational transportation technology company that realized an increase of over 10X in software development productivity with JourneyApps.

At first, this company approached a custom software development firm to digitize part of its internal operations. The required app needed to work on iOS and Android devices, as well as on the web. The quoted price, however, was too high. This led them to decide to build the app internally (assigning one of their interns to the project) and choose JourneyApps as their development platform.

By comparing the time originally quoted1 by the custom software development company and the actual time it took to build the application on JourneyApps, we can see the quantified benefits of development on JourneyApps.

The Requirements

Here are the key aspects of the requirements for the app build:


The application has two main user roles: employee and manager, as well as an admin role. Each role then has specific feature requirements and view requirements.

Timeline Without JourneyApps

The company shared their requirements with a 3rd party software development group and received the following estimate to build the application with a team of 3 full-time developers:

Project Phase Estimated Duration
Design: Architecture & UI design 6-8 weeks
Development: Includes all features listed above; assumes 3 full-time developers 16-18 weeks
Testing: QA + UAT + bug fixing 2 weeks
Launch & Warranty: 30-day warranty begins at launch 4 weeks

Timeline With JourneyApps

JourneyApps was subsequently chosen as the platform on which to build the application and the customer assigned an intern to the project (a Computer Science major on a summer internship program). Below was the actual time it took the intern to complete the project on JourneyApps:

Project Phase Actual Duration
Design: Architecture design; UI design 4 hours; 2 hours
Development: Includes all features listed above; only 1 junior developer (intern) 186 hours
Testing: QA + UAT + bug fixing 14 hours
Launch & Warranty n/a

Building the application on JourneyApps all but eliminated the design phase of the project (from 6 weeks to 6 hours), but the biggest win was in the development and testing phases of the project. Here, it would have taken 3 full-time developers around 2,160 hours (18 weeks x 40 hour weeks x 3 developers) to build the application from scratch, and complete their testing.

On JourneyApps this only took 200 hours, meaning a time reduction of 10.8x (a saving of almost 2,000 total hours)!

How Can a Junior Dev Build So Quickly on JourneyApps?

JourneyApps and its OXIDE IDE allows smaller teams and more junior developers to build complex business apps much more productively:

OXIDE IDE Leads to Increased Productivity

  • OXIDE is an online IDE, which means there is no development setup. The default OXIDE setup allows developers to be productive immediately.
  • OXIDE has a familiar UX for developers — it is similar to other modern IDEs, but simplified by default.
  • There are workspaces dedicated to specific functions, e.g. building views, designing the data model, and managing app deployments. Developers can customize the workspaces to suit their specific workflows.
  • Auto-deploy to a testing environment means that developers can see their application live as they develop. This provides for a really fast build-test-debug loop. Single-click deploy to staging and production environments means that deployment is always simple and quick.

Build Apps Once, Run Them Everywhere

  • Apps built on JourneyApps run off a single codebase and can be deployed across platforms (iOS, Android, Windows, Linux, Mac), devices (smartphones, tablets, computers), and the web.
  • To achieve this level of responsiveness with pro-code tools typically requires thousands of lines of code and hand-coding per operating system or per device-specific variations on how the app behaves.

Offline Data Sync Support

  • In JourneyApps you get market-leading bi-directional relational offline data sync with zero configuration. It just works out of the box.
  • With a pro-code stack, this is typically extremely expensive and difficult to build, requiring very senior developers.
  • Low-code tools typically either don’t have any offline functionality and those that do have some offline functionality, tend to be extremely limited (e.g. just basic caching of individual data objects — no bi-directional relational sync).


  • CloudCode makes it very simple to set up backend integrations and backend tasks.
  • With a few clicks, developers can have serverless backend tasks running on a schedule, triggered by the app, triggered by external API requests, or via a JourneyApps webhook. Virtually zero configuration is required.

Code as The First-Class Citizen, Complemented by Visual Point-and-Click Tools

  • Top-class autocomplete and error-checking reduces the amount of time that the developer has to spend on writing code and correcting syntax.
  • The View Designer helps to quickly prototype apps using visual tools, reducing time further.

Data Tables

  • With JourneyApps you get Excel-like powerful data grids/data tables with a few dozen lines of code, with super-powerful functionality like filtering & sorting, copy & paste, keyboard shortcuts, frozen rows & columns, collapsible rows & columns, etc.
  • With a pro-code stack, this is typically extremely expensive and difficult to build, and requires very senior developers.
  • With a low-code tool, this kind of powerful functionality is typically simply not available.

Secure By Design

  • With JourneyApps, all your apps are secure out of the box.
  • Junior developers can build applications quickly knowing that the underlying platform is secure by design — avoiding massive overhead and risk.

A Complete Full Stack

  • Everything you need to build your app is provided by the platform, whereas with open-source software such as Flutter you need to make many architecture decisions such as which DB system to use, which backend to use, etc. This takes a lot of time.
  • Furthermore, on other platforms, once you have decided on a database, you have to hand-code the marshaling of data between the different layers of the app (e.g. from the backend database to the in-memory representation in the cloud, and then down to the device, and to the on-device data representation).
  • JourneyApps includes a backend DB which includes automatic audit trails and configured APIs for your app, push notification support, tools for managing the life cycle of the application, and more.

Pre-Built UI

  • On JourneyApps you get pre-built UI components with an automatic layout engine.
  • With a pro-code stack, UI development is very time-consuming. You have to spend a ton of time on coding e.g. HTML and CSS, styling, layout, responsiveness, etc.

In Conclusion

Using JourneyApps can reduce your development time by up to 10.8x. Try For Free today and save thousands of build hours per application.

  1. While the custom software development company did not build the actual application on Flutter, the quoted timelines are fairly accurate based on their experience in providing quotes for applications on a regular basis. 

← Back to all posts


The development platform

for industrial apps

Try For Free