Swiftic Review – Is this the App Maker to Use in 2022?

Creating an app for your business used to be a major decision. The costs involved and whether your clients or customers will actually use it in a manner that provides a good return on your investment were always a cause for concern.

Then there is the general upkeep. For a long time, it seemed that utilizing an app as part of your commercial armory was mostly reserved for big companies that could afford the outlay. Not any more.

These days there are a number of online app creator services that allow the small business owner to have a dedicated mobile presence with relative ease.

Swiftic is one such platform that has been causing a bit of a stir due to their (alleged) simple 4 stage app creation process: sign up, add content, create, and launch.

Of course, ease of use is what they say.  To see how they hold up to closer scrutiny, we signed up to take a look.

What follows is an in-depth look into Swiftic’s app-building platform, plus some of our thoughts on the good and bad points of using them when launching an app for your business.

Who is Swiftic?

Swiftic traces its roots to Conduit Limited, which was a software innovation company created in Israel in 2005.

However, its entry into the app development niche can be traced to Como DIY, which was an app-building service that allowed its users to build their own custom mobile apps based on the templates is provided.

These mobile app were described as Do-It-yourself (DIY) apps because the users were not really experienced programmers and no expert app builder was hired during the app-making process.

Como DIY was established in 2014 as a branch of Conduit Ltd, and it quickly became the dominant business line.

Later, Como DIY purchased the mobile customer loyalty platform, Keeprz, for about US$45 million, and this allowed it to integrated loyalty programs into mobile apps built for SMEs. Shortly, thereafter Como DIY was rebranded as Swiftic.

Swiftic focuses on mobile apps that can be deployed as cloud-based applications to be installed in mobile devices, especially smartphones.

Also, because it enables a business to develop its own unique mobile app, this app is not based on an existing PC program and can thus be described as a novel mobile app built to meet the needs of the business.

Since its inception as Como DIY and later rebranding, Swiftic has managed to attract more than 25 million users and over 2 billion user interactions.

Among these users, over 1 million have built and published their mobile apps via ComoDIY-Swiftic, and currently more than 100,000 mobile apps are created monthly via this cross-platform app-building framework.

A Quick Overview of Swiftic’s Services

Swiftic is a cross-platform app-building platform that allows amateur app makers to create highly-functional and user-optimized hybrid and web-based mobile apps.

Its framework-based development environment uses a web interface platform to allow small businesses to create mobile apps that deliver exceptional user experience (UX) to their customers.

It also comes with a customer loyalty program platform that allows businesses to provide coupons and loyalty programs to their customers via mobile apps.

Regarding app features, Swiftic allows the business to build a goal-driven app with a customized user interface (UI) that makes the app easily recognizable, as well as optimizes this app for user experience by allowing for the provision of an easy-to-navigate, aesthetic, and task-oriented interface with minimized keystrokes.

Relatedly, Swiftic uses the UI philosophy of what-you-see-is-what-you-get, or WYSIWYG, which is possible because it provides app building templates that are pre-loaded with XML data for implementing UI layouts.

Moreover, Swiftic can submit the created app to 3 ADP marketplaces: Google Play Store, Apple App Store, and Amazon Appstore; as well as provide tools for app store optimization and conversion rate optimization so that the app generates profit for the business.

Evidently, Swiftic targets small businesses with its ready-to-use app building platform that can allow anyone (including non-programmers) to build a mobile app and then submit it to Google Play Store.

Even so, Swiftic does not support hot reloading, which means that changes made in the app source code cannot be immediately implemented in deployed apps.

To appreciate how the Swiftic development platform can be used to develop and deploy a mobile app, there is need to understand how a mobile app is developed and deployed.

Mobile App Development and Deployment

Usually a mobile app features a set of productivity functions, which informs its operations and its importance in the market.

These productivity functions range from personal assistance functions – including information retrieval utility – such as maintaining a local contact database (for storing and retrieving contacts), calendar reminders, and messaging via email and SMS texts; to enterprise-grade services such as work automation and cloud accounting.

For apps build using the Swiftic platform, this range of functionality is extended to commerce operations such as purchasing, billing, order placement, and order tracking.

Therefore, the SME benefits from a commerce-customized mobile app that automates business operations such as order tracking, and ticketing for support, as well as allows for the integration of location-based services (LBS) based on the internet protocol (IP) address or global positioning system (GPS) coordinates.

• Related Content: TimingCube Review – An App to Time Your Trades

Even so, how is a mobile app created?

There are two ways of creating a mobile app: using a PC application as a template upon which the app is built, and building the app from scratch. This process of creating a functional mobile app is described as mobile app development.

This development takes place on a development platform. Conventionally, the mobile app needs to be built in an integrated development environment (IDE) and then tested within this IDE using a virtual emulator that simulates the physical mobile device.

The development platform is the integrated programming environment that enables an app builder to develop a mobile app and then deploy it so that it can be downloaded and used. This platform also allows for app management.

A good development platform not only provides for this develop-deploy-manage app pipeline but also provides tools for testing the developed app before it is deployed.

Swiftic provides an integrated mobile app development platform that allows a small business to create its own customized app, and then upload it to an app store where its customers can download and install the app so that they can access and use the services the business offers.

There are 3 types of mobile apps that one can create using the integrated app development platform provided by Swiftic. These types are:

Native App

This is an app built to run on a specific mobile OS, such as an Android app or an Apple app.

Web-based App

This is an app coded in web-development programming languages like HTML (HyperText Markup Language), CSS (Cascading Style Sheets), and Javascript; and are deployed via the internet to run on web browsers.

Its database is hosted in a remote server hence one must be connected to the internet to access and use this app. Basically, this mobile app is a modified web application.

A web application is an app that runs within a web browser and uses client-side or server-side processing to deliver an app-like user experience.

Hybrid App

This is an app that features both properties of a native app and a web-based app, and as such must be able to support both web-based and native app technologies.

It is usually developed using Apache Cordova technology. Normally, the code base used – in the app – can run on different mobile operating systems, that is (i.e), the code base is cross-platform. Most of the apps built on the Swiftic platform are hybrid apps.

Regarding resource usage, the web-based app uses the least computing power and storage space, while the native app uses the most storage space and processing power.

As mentioned, the hybrid apps are built using the Apache Cordova technology. This technology started out as PhoneGap, and its core technological breakthrough can still be witnessed in the app-building process used by Swiftic.

PhoneGap to Apache Cordova

PhoneGap is a development framework created in 2009 by Nitobi for building mobile apps. It allows programmers to build mobile apps using HTML, Javascript, and CSS.

This allows mobile apps to be deployed to different smartphone platforms (or marketplaces) so that different types of Android smartphones can download and use the app.

In 2011, this development framework (DF) was acquired by Adobe and renamed Apache Cordova. Initially, Cordova was platform-specific, i.e to build iOS apps, one needed to use a Mac computer running macOS, while to build Windows mobile apps, one needed to use a Windows PC.

Later, Adobe integrated its proprietary cloud compiler into Cordova hence transforming this development framework into a cross-platform app builder.

Following this integration with the cloud compiler, Apache Cordova could use Javascript as its code logic, while the web programming languages used for rendering the source codes of mobile apps are HTML5 and CSS.

After the mobile app has been built in this DF, its source code was compiled into a working app by the cloud compiler.

This move from app specificity (to a specific Mobile OS) to cross-platform app support was copied by ComoDIY-Swiftic.

Initially, Swiftic focused on creating mobile apps for iOS, and then later the Android platform.

Swiftic Chose the Cross-Platform Route

Android OS is a Linux-based open-source operating system that has spawned off the Android ecosystem which includes this OS, middleware, and mobile apps for end-users.

The key middleware are Java and AIR for Android, as most Android devices come with the OS pre-installed with the Java Virtual Machine (JVM) on which the software stack – i.e. the mobile apps – runs, which means that most Android apps are created using Java programming language which also carries the advantage of being a cross-platform language.

This decision to build apps to run off the JVM allowed Swiftic to pre-code app templates for the 2 main Mobile OS, Android OS, and iOS.

For anyone trying to create an Android mobile app from scratch, (s)he needs to at least be able to write Java programs.

Even so, most small businesses do not have the finances to hire a software engineer or app developer to build their mobile apps.

It is this category of small businesses that Swiftic targets and its business model is to provide a ready-to-use app building platform that can allow anyone (including non-programmers) to build a mobile app and then submit it to Google Play Store.

A good thing about Google Play Store is that all Android apps are treated equally.

The development platform provided by Swiftic comes bundled with both front-end and back-end development tools. The key front-end development tools are design tools and software development kits (SDKs). These design tools allow for theming of the app so as to build an aesthetic user interface (UI).

On the other hand, the SDKs allow the app to access the different features of the mobile device including its location-based services (LBS), camera, and local storage. Additionally, it provides tools that provide cross-platform support to the running apps.

The back-end development tools allow for data routing, integration with back-end server systems, and user authentication and authorization. Some tools also provide a reusable business logic base. Moreover, some tools provide security add-on layers for app wrapping and data encryption.

User Interface (UI) and User experience (UX)

As a professional provider of templates and base program code for building mobile apps, Swiftic places much emphasis on 2 key (app) development processes: user experience (UX) and user interface (UI).

The user interface is the graphical shell (like the virtual window display) that displays the features and components of the app to the user, as well as allows the user to interact with the app and its component parts. The UI allows the app user to open, navigate, and close the app.

Normally, a good mobile app has a unified user-friendly interface that is aesthetically-pleasing. UI is a component of app design, and during app development, it is programmed as an asset sheet that includes the critical extensible markup language (XML) source code. Swiftic has already preprogrammed these asset sheets, and each sheet is known as a design template.

Swiftic uses the UI philosophy of what-you-see-is-what-you-get, or WYSIWYG. This is possible because each available template is pre-loaded with XML data for implementing the UI layout.

It also provides a simulator that mimics the physical mobile device that the app is designed to run in, and this physical device is designated as the target device.

This simulator allows the user to visualize how the app will appear in the target device. Each template can accept additional codes called plugins to be added to it so as to create a UI module.

The multiple UI modules provided by Swiftic allows the developer to build an app that has been tweaked for optimized performance on the target device.

The end goal is to keep this developer focused on building a good UI because it is this UI that customers will use to interact with the app and access the app services.

Some of the UI templates are heavy on building a conversational interface. The conversational interface provides a display interface that allows the user to interact with the app through text, e.g through chats in a chatbot or chat room in customer support systems.

Another conversational interface is the voice assistant, e.g Amazon Echo. This interface is designed to emulate human-to-human conversations where words, not graphical elements, are used.

This conversational interface provides a practical way for users to interact with an app offering commercial services without causing app fatigue, a phenomenon where the user is unable to properly use the app because (s)he is overwhelmed by its graphical-based UI features.

Another key component of app development and usage is the user experience (UX). UX is a collective term that describes how the app user feels when using the app.

UX determines shapes the attitude of app users to the app, and impacts on whether they like the app or not. Needless to say, an app with a bad UX will face rejection in the market while the one with a good UX will benefit from market acceptance.

The key factor that determines UX is app performance in terms of UI and the ability to deliver what it promises (which determines the level of user satisfaction).

During app development, app performance is considered by factoring the following before building the software code: target device hardware – i.e its form factor, screen size, mobile OS – and input and output capabilities, as well as device mobility.

Swiftic provides an inbuilt simulator for the various smartphones and mobile devices that can run the app, and the app builder can assess how the app performs in these virtual devices. A virtual simulated device used to run an app and assess its performance is called a virtual emulator

Swiftic intends its users to build apps with good UX, and the virtual emulators provided allow them to test-run their apps.

A good UX creates a functional consistency that ensures that users using this app on different target devices (all) get an almost similar range of application functions.

To extend the app function after it has been deployed, the app can be linked to other smartphone apps, and this linkage is provided by the Application programming interface (API). Therefore, API support allows the app built through Swiftic to benefit from third-party support.

The UI and UX are created by the computing code that runs the app, and in native apps, this code is stored in the smartphone while in the web-based app, the code is stored in a remote server called the mobile app server.

Even so, because most apps made on the Swiftic platform are hybrid apps, then most of their computing (source) code is stored in a mobile app server, while the app is deployed using the software as a service (SaaS) model.

For the web-based or hybrid mobile app, its source code is stored in the cloud. The computer that provides this cloud storage runs on an OS that allows the app to access its cloud data, besides allowing the app to run from the cloud so that it (app) can retrieve, modify, and store data in its cloud data center.

This cloud infrastructure that provides the hardware platform, OS, service software and the data access layer (DAL) that allows a hybrid or web app to store, modify/manipulate, and fetch and retrieve data is called the back-end infrastructure.

Swiftic can offer businesses without dedicated cloud service providers a back-end infrastructure to run their deployed DIY mobile apps.

Also, because the provider of a back-end infrastructure for running mobile apps is said to offer a unique service called Mobile Backend as a Service (MbaaS), then it is evident that Swiftic offers MBaaS services.

Swiftic allows users to create apps whose UI features an easy-to-navigate, aesthetic, and task-oriented interface with minimized keystrokes.

Developing a user-friendly UI is important because the UI forms the front-end of the app which users (mainly customers) can use to judge and rate the business (that developed and owns the app).

As expected, Swiftic provides a platform for businesses to create mobile apps that are aesthetically-appeasing and highly-functional so as to deliver exceptional UX to their customers.

If the app needs to transmit and store sensitive or confidential data, then it needs to have an inbuilt management layer that sets authentication controls and determines which data can be stored in the device, as well as controls file sharing to avert potential data leakage.

This management layer is called an app wrapper, and the process of integrating an app wrapper into a mobile app is called app wrapping. App wrapping can be provided for apps built via Swiftic to process and transmit confidential business information.

Even so, Swiftic does not support hot reloading. Hot reloading is a process that allows the app builder to make changes (or modifications) in the app in real-time. Hot reloading allows for the effect of the changes to be operationalized immediately in the deployed apps.

App Templates and Forked Modules

Currently, Swiftic uses iOS SDKs and Android SDKs, along with HTML5, Javascript, and CSS to build templates, which are then used to create apps. Also, these templates feature development modules that help to build the source code of the app.

Relatedly, Swiftic has forked some of its development modules from existing software development platforms. These modules allow Swiftic to build highly-functional and stable apps.

These forked modules include the following 3 Javascript modules, 2 ruby modules, a C# module, a Java module, and 2 Objective-C modules.

Javascript modules

• DIY_FLOW which is based on Project-s-v2 that was developed by Edo Magen.
• como-generators that is based on Generator-Angular built by Yeoman.
• angular-httppostfix that is based on Angular-HTTPPostFix built by Ezekiel Victor.

Ruby Modules

• appium_tests that is based on appium_tests developed by Ma-or Hayoun.
• capistrano-unicorn which is a Capistrano integration for Unicorn developed by SFSE Karan.

Objective-C modules

• PDF-Reader which is based on Reader built by VFR for the iOS platform.
• Trimmerapp that is based on Trimmerapp developed by StageEV Conduit.
• IdentityServer4 is an Authorization Server Framework built using C# by Identity Server.
• cordova-android is a Java application based on Apache Cordova.

Application Distribution Platform

Normally, the owner of a Mobile OS collects all mobile apps that can run on its OS into a single storage and delivery platform called the application distribution platform (ADP).

It is called ADP because mobile app developers upload their apps to this platform so that users can access it, and then download it to their mobile devices.

Therefore, the ADP allows for apps to be uploaded and downloaded, as well as provides a unified repository that stores these apps in secure cloud servers.

The Mobile OS providers create, maintain, and operate their own unique ADPs. For Linux-based Android OS, the ADP is called Google Play Store; while for Apple’s iOS, the ADP is called the App Store. Microsoft has the Microsoft Store ADP for Windows 10 Mobile OS.

Interestingly, Amazon, Inc., runs its own ADP for Android apps, and it is called the Amazon Appstore. Furthermore, Android apps can also be hosted in the Opera Store.

Some ADPs are not operated by Mobile OS developers, and they are called independent ADPs. F-Droid is an example of an independent ADP that hosts apps that run on Android OS.

When the app is downloaded from the ADP to the smartphone, this smartphone is described as the target device, and this description is important because app developers usually optimize their apps to run on specific target devices.

For app developers who sell their apps via the ADP, the profit obtained is split between the developer and the ADP provider (who charges a specific percentage of the sales price). This explains why the same app is priced differently on different ADPs.

This is important to keep in mind because Swiftic does the app submission to different ADPs for a developed on its platform, and this app can be priced differently in the different ADPs, e.g it may be expensive in the App Store as compared to the Google Play store.

Sometimes, the app can be installed in the target device without being downloaded from the ADP. This form of app installation is described as a manual installation, and the app must be run in an executable format such as an Android application package (APK) for Android Apps.

Swiftic obviates the need for manual installation by providing a system for uploading the created app to an ADP.

Still, Experienced app developers can use the Swiftic platform to build apps and then export these apps as APKs for installation in target devices for real-world testing of app performance.

Swiftic places more emphasis on Google Play Store ADP because this ADP has the largest repository of mobile apps (in excess of 2.4 million apps, most of which are free) and it has the most downloads of any ADP to date.

Two other ADPs where the Android apps made using Swiftic can be ported to are App Store ADP and Amazon Appstore.

Building the App with Swiftic – A Summarized Process

Before app development using the Swiftic platform, the business/SME should consider the following:

Projected habits of the end-users

These end users are the customers using the app to access the information and services offered by the businesses.

Considering their habits allow the business to build a goal-driven app, e.g for a small cafeteria, it must consider the fact that its customers will need a menu so that they can scroll and see the available meals that they can order.

After considering this consumer habit, the business can then build a browsable app with this feature, along with a search function, meal pics and prices, and a payment module so that the customers can pay for the meals they order online (which is the goal of the business building this app).

UX and UI of the app

This has already been discussed above.

Capabilities of the smartphone

How to leverage the inbuilt capabilities of the smartphone, such as LBS, to tailor advertisements and services through the app.

Testing & Deployment

How to test the app before deploying it. Fortunately, Swiftic provides a testing platform based on virtual emulator running Andoird OS, iOS, and iPad OS. This test drive must access the graphics-heavy UI, as well as app functionality and UX.

Consider app functionality during times of low signal strength and low internet speeds.

Using Swiftic to Create your App

After the aforementioned considerations, the business, SME, or app builder creates an account on the Swiftic platform.

This account serves as the console that provides the control panel for building, deploying, and managing the app.

This means that Swiftic provides a single control panel for app creation, deployment to an ADP, and post-deployment app management.

The unique UI of the app can be considered as the online storefront provided by the business/SME.
App Publishing on the ADP.

Submitting the app to an ADP

After app creation, one needs to submit the app to an ADP. Swiftic streamlines this app submission process. Swiftic allows the SME to submit the app to 3 ADP marketplaces: Google Play Store, Apple App Store, and Amazon Appstore.

Swiftic provides a separate tab for each of these 3 ADPs. Swiftic can submit the app to any, or all, of these ADPs on behalf of the SME.

If Play Store is the desired ADP marketplace, Swiftic can do the submission on behalf of the SME. This is possible only if the SME fills the submission form with accurate details, which are needed during the submission process.

There is also a submission form provided by Swiftic for mobile apps that need to be submitted to Amazon’s Appstore. Equally, there is a submission form for Apple’s App Store.

Approval by the ADP provider

After Swiftic submits the app to the ADP, one must wait for the app to be approved by the ADP provider, and the approval status is relayed by Swiftic to the SME or app owner.

A key benefit of allowing Swiftic to do the app submission to the ADP is that it allows for auto-updating of the deployed mobile app.

Likewise, Swiftic provides tools for improving the visibility of the app in the store, which consequently improves the app ranking in the ADP.

This process of optimizing app ranking in the ADP is called app store optimization (ASO). If this ASO leads to increased app downloads, then it is said that the ASO has achieved conversion rate optimization (CRO).

Pricing Structure

As mentioned earlier, Swiftic provides 3 service plans:

• A monthly plan @ $39
• An annual/yearly plan @ $396
• A 2-year plan @ $696

Pros and Cons of Using Swiftic

Wrapping things up

Swiftic provides an integrated cross-platform app development framework that allows for the fast development of mobile apps for non-programmers who need these apps.

Swiftic uses iOS SDKs and Android SDKs, along with HTML5, Javascript, and CSS to build templates, which are then used to create these apps hence allowing amateur app developers to build functional mobile apps.

Likewise, the process of designing the app is easy; while the allowance for plugin and API integrations allows the app to benefit from third-party support.

Relatedly, Swiftic streamlines the process of app submission to an ADP, as well as provides for auto-updating of the submitted/deployed app. Lastly, Swiftic provides tools for improving the visibility of the app in the store, and this form of ASO enhances the CRO of the app.