Optimal code reuse means that the majority of your app consists of code that has already been tested and proven in numerous other projects, drastically reducing the risk of bugs as well as shortening the overall development time.

When implementing apps we use a high-level, declarative, programming abstraction designed to maximize code reuse between different apps. Instead of writing each app from scratch, thousands of apps can effectively reuse a huge amount of code, tests and other infrastructure.

When implementing an app these components specify what the app does, as defined by the dataflow between your service (the backend) and the user, without having to be concerned with how it is done on the specific platform (mobile phone, web) the app is running on - that job is instead handled by the platform drivers.

While high-level components are used to define “what the app should do” the platform driver is the part that deals with the low-level specifics of how different app features and components are implemented on Android, iOS and the web.

Separating concerns is of course not a novel concept, it is considered a best practice for a wide range of software design scenarios. What makes the Fuse App Engine different is the level of abstraction it provides, with much larger blocks of functionality being parametrized and made available through the higher-level declarative component API.

We use React Native to implement the platform drivers for iOS and Android. However, we take a conservative approach to the wider React Native ecosystem and its challenges with external dependencies. This means that we thoroughly scrutinize any third-party packages we use, as well as carefully evaluate what functionality we need to build and maintain in-house.

While software frameworks and APIs are a key to what we do, an equally important part is the work to structure and automate the many different stages of app development and maintenance.

To achieve efficiency, predictability and scalability throughout the entire app lifecycle Fuse has developed thorough processes and tools for specification, development, user testing, continuous integration, change requests, updates, monitoring and more.

This means that the success of your project is a function of well-defined processes and tools, as opposed to traditional app development where you are reliant on “the right team being available” and subject to the preferences, strengths and weaknesses of an individual developer or project manager.

Apps, just like any other piece of software, can experience errors. And when running on a wide range of devices it can be difficult to identify the cause of a problem and fix it.

As part of our service, we perform automatic monitoring and logging of any issues occurring in your apps. This enables us to fix problems quickly and efficiently, often without the need for bug reports from the users. The Fuse App Engine can also collect usage analytics which helps you understand the needs and behaviours of your users.

Which contains the data and business logic everything is built on. Fuse takes responsibility for the app, from development to publishing and maintenance, while you, or one of your partners, provide the backend that the app communicates with.

The backend should be ready for use through the internet. If it has previously only been used internally you should consider building a new app-specific API to abstract the system and minimize the amount of infrastructure you make available on external networks.

Should be encoded in the API used to access the backend. A good rule-of-thumb is that the API endpoints should be designed according to what the app will do with the data, not how the data is stored inside the backend. This means that you, as the product owner & domain specialist, retain control of what the app does. It also ensures that different versions of the app (e.g. on iOS, Android, web) operate in the same way, and it allows you to make changes to the internal logic of the service without relying on users to update the apps on their phones.

This specification defines a clear contract between the back- and frontend. The Fuse App Engine can automatically convert this into TypeScript client code which is used when implementing the app with high-level components. This ensures end-to-end type safety, greatly improves testability and allows us to quickly uncover potential problems early on in the development phase.

We can, of course, help you evaluate this and provide recommendations for how to get everything in place.