BlazeMeter, continuous testing platform,  is a perfect solution for your performance needs. BlazeMeter is an open-source tool that supports Web, Mobile and API implementations. You can perform large scale load and performance testing with the ability to tweak parameters to suit your needs.

We will learn step by step process on using BlazeMeter for API testing.

Register for BlazeMeter

Enter your information on the BlazeMeter site to register and get started

Configure Your First Scenario

The first time you login, you will be taken to default view of BlazeMeter with default workspace and project. Let us start configuring a new scenario.

Create a New Project

1. Select Projects -> Create new project
2. Name project
3. Select Create Test
4. Select Performance Test
5. Now you are taken to configuration tab

Update Your Scenario

1. The left section here has your test specifications
2. Tap on Edit link and start updating your project name, let it be “FirstLoadTest”
3. You can define scenario and test data in Scenario Definition section
4. For this Demo we will configure API endPoint, tap on Enter URL/API calls (see picture below)
5. In Scenario Definition enter “https://api.demoblaze.com/entries“. So we are load testing this endpoint with GET call
6. Lets Name this scenario “DemoWithoutParameters”
7. Tap on three dots next to Scenario definition and duplicate the scenario
8. Name this as “DemoWithParameters”

Create TestData

1. Next to Scenario Definition we have TestData section, tap on it
2. You can choose from options available, for this demo we will go with “Create New Data Entity”
3. Lets name it “DemoTestData” and Add it
4. Tap on + icon next to entity created for parameterization options
5. In this example we will select New CSV File
6. You will be taken to a data table. Rename “variableName1” to “Parameter1” and “variableName2” to “Parameter2″(our variable names are “Parameter1” and “Parameter”)
7. Enter values as “Value1” and “Value2” and Save
8. Configure these parameters in Query Parameters section (See picture below)
9. Now we have successfully completed building a scenario with two endpoints, you can configure one or more endpoints in one scenario

Configure Your First Test Run

1. Scroll down the scenario definition window to see Load Configuration section
2. Enter Total Users, Duration, Ramp up Time. For now we can just test with 2 users, Duration: 1minute, RampupTime: 0
3. Once you update these details observe the graphical representation of how your Load Test is going to be in the graph displayed in this section.
4. We can also limit Requests Per Second(RPS) by enabling the toggle button for “Limit RPS” and select requests you need to limit per second
5. We can also change number of users at run time, but this is available with only Enterprise Plan.
6. Lets configure LoadDistribution now in “Load Distribution” section which is right below the “Load Configuration” section
7. Select the location from where you need the requests to trigger.
8. We can select multiple locations and distribute load across different locations, but again this feature is available with only enterprise plan
9. For now, lets proceed by selecting one location

Failure Criteria

1. Failure Criteria is the best approach to immediately know your LoadTest Results
2. Do you have your failure criteria defined? If yes, you can configure that in this section. This is optional, you can skip if you don’t have failure criteria defined.
3. You can configure multiple failure criteria as well
4. Enable “1-min slide window eval” for evaluating your loudest prior to execution
5. Select “Stop Test?” checkbox if you want to stop the execution in case of failure
6. Select “Ignore failure criteria during rampup” to ignore the failures during ramp-ups
7. You can add one or more failure criteria and select this option uniquely for each criteria
8. Select the option “Enable 1-min slide window eval for all” on top right of this section to enable for all provided failure criteria

Test Your Scenario

1. Run your scenario by clicking on “RunTest”
2. Wait for launch Test window to load completely
3. Now click on “Launch Servers” button
4. Click on “Abort Test” to abort your execution any time
5. Observe your execution go through different stages (Pending, Booting, Downloading and Ready)
6. Once it reaches Ready you can see your execution progress
7. Once the execution is done you can view the summary with status as passed/failed

Analyze Your LoadTest Results

1. The important part of performance test is to analyze your KPIs
2. You can see different KPIs in test results summary
3. To understand more navigate to “Timeline Report” section, bottom left you can see “KPI Panel”,this panel contains different KPIS.These KPIs can be analyzed as required
4. By default it provides generalized view, you can select single endpoint to analyze KPIs for one particular endpoint

Schedule Your Load Tests

1. BlazeMeter is continuous Integration tool, you can schedule your executions and view results when required
2. Select your test from Tests Menu on top
3. On to left of project description window you can find SCHEDULE section
4. Tap on Add button next to it Schedule to see schedule window
5. Configure the scheduler with required timings and Save the scheduler
6. The new scheduler will be added to your project
7. Delete it by tapping on Delete icon
8. You can add multiple schedulers
9. Toggle on/off to activate/deactivate the schedulers

BlazeMeter Pros/Cons

If you are looking for a tool that services your performance needs, BlazeMeter is your best option. You can generate scripts with its scriptless UI, simulate loads and run your tests. You can also simulate the spinning up servers, script runs and results generated within seconds.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

In today’s tech-driven world, the ability to visualize data spatially has been vital for various industries. Enter ArcGIS, a Geographic Information System (GIS) developed by ESRI, which is here to help us solve our client’s needs. Let’s chart our way into the world of ArcGIS and how it empowers businesses to harness the full capabilities of today’s mapping software.

Overview

At its core, ArcGIS is a comprehensive mapping solution that enables you to deliver a high quality experience for your users. It integrates various geographic data sets, allows users to overlay layers, analyze spatial relationships and extract meaningful insights. The user-friendly features and wide array of capabilities differentiates ArcGIS from competitors.

Standard Features

ArcGIS offers a plethora of map features designed to level up your user’s experience. Basic features such as customizable basemap tiles, display the user’s location in real-time and intuitive pan and zoom functions all makes map navigation a smooth and familiar experience.

However, the true power of ArcGIS lies in its ability to visualize and interact with objects on a map. Custom-styled map markers with the same look and feel of pre-existing symbols, enables users to identify and track objects just as they’re used to seeing them. And if you have many objects in close proximity to one another? Group them together with “clusters” that can break apart or regroup at specific zoom levels.

Advanced Features

By providing methods to display object details or toggle visibility based on predefined groups, ArcGIS gives businesses the power to streamline asset management. And that just scratches the surface of the advanced features available!

With ArcGIS, you can draw on the map to indicate an area, or even let your users draw on the map themselves. You can apply a “highlight” styling on visible objects that meet a criteria. You can search for objects with a multitude of filters, such as object type, any custom attributes (defined and set by your organization’s data management team), or even search for objects within a defined geographical boundary.

The limit of its applications is your imagination.

Offline Maps

But what happens when you’re off the grid? Won’t we lose all of these convenient features? Fear not, as ArcGIS enables continued productivity even in offline environments.

By downloading map sections for offline use, users can still access critical data and functionalities without internet connectivity, a feature especially useful for your on-the-go users.

If storage space is a concern, you can decide which data points for objects are downloaded. So if your users just need to see the symbols on the map, you can omit the attributes data to cut down on payload sizes.

In conclusion, ArcGIS stands as one of the leaders in mapping technology, empowering businesses to unlock new opportunities. From basic map features to advanced asset management capabilities, ArcGIS is more than just a mapping solution—it’s a gateway to spatial intelligence. So, embrace the power of ArcGIS and chart your path to success in the digital age!

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

Flutter is great framework for cross platform development. It allows you to make pixel perfect apps that are generated into native code, but what happens if you need to use existing code in iOS or Android directly? For situations like these, Flutter allows you to use platform channels.

Platform channels give you access to platform-specific APIs in a language that works directly with those APIs. Platform channels are available for Kotlin or Java on Android, Swift or Objective-C on iOS and macOS, C++ on Windows and C on Linux.

More information can be found on this here https://docs.flutter.dev/platform-integration/platform-channels

The platform APIs provided by Flutter work as intended, but the whole process is a bit cumbersome to set up. Pigeon allows us to use type safety and code generation to make this process a whole lot simpler.

Create a Pigeon Plugin

We will go ahead and create a simple example api.

Let’s start by creating a new plugin called pigeon_example

flutter create --org com.example --template=plugin --platforms=android,ios,linux,macos,windows -i swift pigeon_example
flutter pub add pigeon
flutter pub get

Platform Channel Types in Swift

Below is a list of supported types in Dart and their swift equivalents. We will use some of the most common types in our example

Define Our API

In order to let Pigeon know what methods we’re going to be exposing we define our API in an abstract Dart class with the @HostApi() decorator, and its methods

Let’s define our Pigeon Example API in a new directory named pigeons.

import 'package:pigeon/pigeon.dart';

@HostApi()

abstract class ExampleApi {
bool getBool();
String getString();
func toggleValue();
}

Generate Pigeon Platform Code

Now we can let the Pigeon package do it’s magic and we can generate some code

dart run pigeon \
--input pigeons/example_api.dart \
--dart_out lib/example_api.dart \
--experimental_swift_out ios/Classes/ExampleApi.swift \
--kotlin_out ./android/app/src/main/kotlin/com/example/ExampleApi.kt \
--java_package "io.flutter.plugins"

Be sure that the paths to all of the files are correct or the next steps won’t work. Generate the code with the output for the platforms needed. This is example is going to focus on using Swift.

Add Method Implementation to the Runner

Next we need to write our native implementation of our methods. When doing this we need to add our files to the runner in Xcode to ensure that they run properly.

class ExampleApiImpl : ExampleApi{
var value = true;

func getBool(){
return value;
}
func toggleValue(){
    value = !value
  }
func getString(){
return "THIS IS AN EXAMPLE";
}

}

Add Pigeon Platform Channel to AppDelegate

You will also need to add this code in your AppDelegate.swift file

@UIApplicationMain

@objc class AppDelegate: FlutterAppDelegate {

override func application(

_ application: UIApplication,

didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?

) -> Bool {

GeneratedPluginRegistrant.register(with: self)

let exampleApi = ExampleApiImpl()

let controller : FlutterViewController = window?.rootViewController as! FlutterViewController

ExampleApiSetup.setUp(binaryMessenger: controller.binaryMessenger, api: exampleApi)




return super.application(application, didFinishLaunchingWithOptions: launchOptions)

}

}

Now you should be able to use your API in Dart code.

import 'package:flutter/material.dart';
import 'package:pigeon_example/example_api.dart';
import 'dart:async';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatefulWidget {
  const MyApp({super.key});

  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final exampleApi = ExampleApi();
  bool value = false;
  @override
  void initState() {
    super.initState();
    initPlatformState();
  }

  // Platform messages are asynchronous, so we initialize in an async method.
  Future<void> initPlatformState() async {
    // Platform messages may fail, so we use a try/catch PlatformException.
    // We also handle the message potentially returning null.
    // If the widget was removed from the tree while the asynchronous platform
    // message was in flight, we want to discard the reply rather than calling
    // setState to update our non-existent appearance.
    if (!mounted) return;
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
        home: Scaffold(
            appBar: AppBar(
              title: const Text('Plugin example app'),
            ),
            body:
                Column(mainAxisAlignment: MainAxisAlignment.center, children: [
              DefaultTextStyle(
                  style: Theme.of(context).textTheme.displayMedium!,
                  textAlign: TextAlign.center,
                  child: FutureBuilder<String>(
                    future: exampleApi
                        .getString(), // a previously-obtained Future<String> or null
                    builder:
                        (BuildContext context, AsyncSnapshot<String> snapshot) {
                      List<Widget> children = [];
                      if (snapshot.data!.isNotEmpty) {
                        children = <Widget>[
                          Text(snapshot.data ?? ''),
                        ];
                      }
                      return Center(
                        child: Column(
                          mainAxisAlignment: MainAxisAlignment.center,
                          children: children,
                        ),
                      );
                    },
                  )),
              Center(
                child: ElevatedButton(
                  child: const Text('Toggle Value'),
                  onPressed: () async {
                    await exampleApi.toggleValue();
                    var val = await exampleApi.getBool();
                    setState(() {
                      value = val;
                    });
                  },
                ),
              ),
              DefaultTextStyle(
                  style: Theme.of(context).textTheme.displayMedium!,
                  textAlign: TextAlign.center,
                  child: FutureBuilder<bool>(
                    future: exampleApi
                        .getBool(), // a previously-obtained Future<String> or null
                    builder:
                        (BuildContext context, AsyncSnapshot<bool> snapshot) {
                      List<Widget> children;
                      if (snapshot.data == true) {
                        children = <Widget>[
                          const Icon(
                            Icons.check_circle_outline,
                            color: Colors.green,
                            size: 60,
                          ),
                          Padding(
                            padding: const EdgeInsets.only(top: 16),
                            child: Text('Result: ${snapshot.data}'),
                          ),
                        ];
                      } else if (snapshot.data == false) {
                        children = <Widget>[
                          const Icon(
                            Icons.error_outline,
                            color: Colors.red,
                            size: 60,
                          ),
                          Padding(
                            padding: const EdgeInsets.only(top: 16),
                            child: Text('Result: ${snapshot.data}'),
                          ),
                        ];
                      } else {
                        children = const <Widget>[
                          SizedBox(
                            width: 60,
                            height: 60,
                            child: CircularProgressIndicator(),
                          ),
                          Padding(
                            padding: EdgeInsets.only(top: 16),
                            child: Text('Awaiting result...'),
                          ),
                        ];
                      }
                      return Center(
                        child: Column(
                          mainAxisAlignment: MainAxisAlignment.center,
                          children: children,
                        ),
                      );
                    },
                  ))
            ])));
  }
}

Now we can see the values from out example API in our Flutter UI. Button toggles will change our boolean value.

Creation of automated QA test scripts in Cucumber provides a low barrier of entry for your QA team. What is Cucumber? Cucumber is Behavior-Driven Development tool that uses Gherkin for scenario syntax. Gherkin is a simple, non-technical language designed for easy maintenance and readability. Gherkin can easily integrate with open-source tools like Selenium, Appium for QA Automation.

We can extend Gherkin syntax in Cucumber test scripts even further with parameters. Parametrization provides the ability to run your scenarios using different test data, write less code and reuse it in multiple locations. In this article, we will learn how to use parameters to create robust test scenarios.

Before digging deep into parameterization, let’s learn about a few keywords!

Useful Keywords:

Scenario: Group of steps that contains user actions and validations.

Test Step: Represents a single user action or validation defined in simple language and starts with keywords like Given, When, Then, And and But.

Step Definition: A method linked to each test step in a scenario. One step definition also can be linked to multiple test steps by following parameterization techniques.

Scenario Outline:  Keyword used for scenarios that contains parameters with values defined. Use Scenario Outline to enable parameters instead of the keyword Scenario. Parameters are defined as variables inside <>. The variables are defined via the Examples keyword.

Examples: Keyword to define variables for a Scenario Outline. I.E. Login credentials for test accounts.

Parameterization Scenarios:

Scenario 1:

Scenario: Verify user can login to Login Page1

Given I am in LoginPage1

When I enter username and password

Then I verify that user is logged into HomePage

And I verify that “home” tab is displayed

And I verify the page title

Scenario 2:

Scenario: Verify user can login to LoginPage2

Given I am in LoginPage2

When I enter username and password

Then I verify that user is logged into HomePage

And I verify that “user” tab is displayed

And I verify the page title and save the title

Parameterize with Pre-defined Values

Parameters that can allow only strongly typed values are considered as pre-defined values.

Let’s look into Given statements from above example – Scenario 1: “I am in LoginPage1” and Scenario 2: “I am in LoginPage2.” The steps are same except for the LoginPage1 and LoginPage2 values. We’re going to create a single step definition for both steps.

@Given(“^I am in (LoginPage1|LoginPage2)$”)

Public void iAmInLoginPage(String parameter1){

//code here

}

Note: The parametrized step definitions will start with ^ and ends with $

Parameterize with Undefined Values

Parameters with undefined values are variables that can have different input values.

We need to test the above scenarios with different login credentials, which can change often. This can be achieved by updating the test data in the scenario, not the entire script linked to the scenario. The test step “When I enter username and password” is the perfect candidate for our use case. Let’s use the Scenario Outline keyword and pass the parametrized values as Examples. We’ll use <> to pass the username and password to our When clause.

Scenario Outlines:

Scenario 1:

Scenario Outline: Verify user is able to login to LoginPage1

Given I am in LoginPage1

When I enter <username> and <password>

Then I verify that user is logged into HomePage1

And I verify that “home” tab is displayed

And I verify the page title and save the title

Examples:

|username|password|

|user1|password1|

|user2|password2|

Note: The above scenario will be executed with iterations for user1 and user2.

The step definitions should use regular expressions to pass values to the scenario as shown below.

@When(“^I enter (.*) and (.*)$”)

Public void iEnterUserNameAndPassword(String username,String password){

//code here

}

Parameterize with Fixed/Default Values:

Default values are parameters defined in test step of the scenario. We are not making use of parameter names, we are directly passing values from test steps instead.

Let’s investigate the test step Scenario 1: “And I verify that “home” tab is displayed” and Scenario 2: “And I verify that “user” tab is displayed.” Both steps are the same except for the values home and user. Even though they aren’t parameter names, they are values used directly in our test steps. However, we can still create single step definition and link it to both test steps.

@And(“I verify that {String} tab is displayed”)

Public void iVerifyGivenTanIsDisplayed(String tabName){

//code here

}

Parameterize Null Values:

There are times when a particular parameter can or cannot have a value within our scenarios. This is where we would make use of Null Value parameters.

Let’s take last steps “And I verify the page title” and “And I verify the page title and save the title.” We can create a parameter to accept “ and save the title” or null. This can be achieved with the regular expression character ? and ensure the parameter has a leading space.

@Then(“^I verify the page title( and save the title)?$”)

Public void iVerifyPageTitle(String saveTitle){

//codehere

If(saveTitle != null){

//code here

}

}

Test scenario parameters enable reuse for test steps across different scenarios. Your code will be more readable and portable as a result. Parameterization decreases our script efforts by linking step definitions to multiple test steps. Adoption of parameters improves code quality which will allow for less errors, easy updates and better overall code.

You will love the code efficiencies that parameters provide! Why not give them a try.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

In the world of Generative Artificial Intelligence (AI), a new era of large language models has emerged with the remarkable capabilities. ChatGPT, Gemini, Bard and Copilot have made an impact in the way we interact with mobile device and web technologies. We will perform a comparative analysis to highlight the capabilities of each tool.

Calculation Metrics:

TP – True Positive

FP – False Positive

TN – True Negative

FN – False Negative

Accuracy = (TP +TN) / (TP + FP + TN + FN)

Recall = TP / (TP + FN)

Precision = TP / (TP + FP)

F1 Score = 2 * (Precision * Recall) / (Precision + Recall)

Our sample data set consists of 100 queries against Gemini AI. The above formula applied calculates the following scores:

Accuracy: (85 + 0) /100 = 85%

Recall: 85/ (85 + 5) = 94.44%

Precision: 85/ (85 + 10) = 89.47%

F1-Score: 2 * (0.894 * 0.944) / (0.894 + 0.944) = 91.8%

Recommended AI Tool:

I recommend Gemini based on its accuracy and consistency.  The ease of integration to the iOS and Android platforms and performance stands out amongst it’s competitors. We will illustrate how easy it is to integration Gemini with 10 easy steps.

Let’s Integrate Gemini into an Android Application!

1. Download the Android Studio preview release Canary build (Jelly Fish| 2023.3.1).
2. Create a new project: File -> New -> New Project
3. Select the Phone and Tablet
   1. Under New Project -> Generate API Starter
   2. Click Next to Proceed
4. Fill all the necessary details
   1. Enter the Project Name: My Application (or whatever you want to name your project)
   2. Enter the Package Name: (com.companyname.myapplication).
   3. Select the Location to save the project
   4. Select the Minimum SDK version: as API 26 (“Oreo”;Android 8.0)
   5. Select the Build Configuration Language as Kotlin DSL(build.gradle.kts)
   6. Click Finish to proceed 
5. Create a starter app using the Gemini API
6. To generate the API. Go to Gemini Studio.
7. Click Get API Key -> click Create API Key in New Project or Create API Key in Existing Project in the Google AI studio
8. Select the API key from the Prompt and paste in the Android Studio.
9. Click Finish to proceed.
10. Click the Run option in the Android Studio.

And you’re up and running with Generative AI in your Android app!

I typed in “Write a hello world code in java” and Gemini responded with code snippet. You can try out various queries to personalize your newly integrated Generative AI application to your needs.

Alternatively, you can just Download the Sample app from the GitHub and add the API key to the local.properties to run the app.

It’s essential to recognize the remarkable capabilities of Generative AI tools on the market. Comparison of various AI metrics and architecture can give insight into performance, limitations and suitability for desired tasks. As the AI landscape continues to grow and evolve, we can anticipate even more groundbreaking innovations from AI tools. These innovations will disrupt and transform industries even further as time goes on.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

Enterprises and organizations that manage products with overlapping feature sets often confront a unique challenge. Their core dilemma involves creating multiple branded mobile applications that share a common codebase while enabling each app to provide a distinct user experience with minimal development overhead. As a leader in custom mobile solutions, Perficient excels in white labeling mobile applications using the power and flexibility of Azure DevOps.

• White Label Your Mobile Apps with Azure
  • Tackling the White Label Challenge
  • Developing a Strategy for White Label Success
    • 1. Application Theming
    • 2. Establishing Your Default Configuration
    • 3. Embracing Remote/Cloud Configurations
  • Coordinating White Labeled Mobile Apps with Azure Pipelines
    • 1. Setting Up Your Build Stage by Platforms
    • 2. Adding Your “Brand” Configuration to Your Build
    • 3. Creating a YAML Job to “Re-Brand” the Default Configuration
    • 4. Publishing Your Branded Artifacts for Distribution

Tackling the White Label Challenge

Consider a scenario where your application has gained popularity, and multiple clients desire a version that reflects their own brand identity. They want their logos, color schemes, and occasionally distinct features, yet they expect the underlying functionality to be consistent. How do you meet these demands without spawning a myriad of codebases that are a nightmare to maintain? This post outlines a strategy and best practices for white labeling applications with Azure DevOps to meet this challenge head-on.

Developing a Strategy for White Label Success

White labeling transcends merely changing logos and color palettes; it requires strategic planning and an architectural approach that incorporates flexibility.

1. Application Theming

White labeling starts with theming. Brands are recognizable through their colors, icons, and fonts, making these elements pivotal in your design. Begin by conducting a thorough audit of your current style elements. Organize these elements into variables and store them centrally, setting the stage for smooth thematic transitions.

2. Establishing Your Default Configuration

Choosing a ‘default’ configuration is crucial. It sets the baseline for development and validation. The default can reflect one of your existing branded applications and acts as a unified starting point for addressing issues, whether related to implementation or theming.

3. Embracing Remote/Cloud Configurations

Tools like the Azure App Configuration SDK or Firebase Remote Configuration allow you to modify app settings without altering the code directly. Azure’s Pipeline Library also helps manage build-time settings, supporting flexible brand-specific configurations.

Using remote configurations decouples operational aspects from app logic. This approach not only supports white labeling but also streamlines the development and customization cycle.

Note: You can add your Brand from the step 2. Adding Your “Brand” Configuration to Your Build into your build artifacts, and reference the correct values in your remote configurations for your brand.

Coordinating White Labeled Mobile Apps with Azure Pipelines

With your application ready for theming and remote configuration, use Azure Pipelines to automate the build and release of your branded app artifacts. The structure of your build stages and jobs will depend on your particular needs. Here’s a pattern you can follow to organize jobs and stages for clarity and parallelization:

1. Setting Up Your Build Stage by Platforms

Organize your pipeline by platform, not brand, to reduce duplication and simplify the build process. Start with stages for iOS, Android, and other target platforms, ensuring these build successfully with your default configuration before moving to parallel build jobs.

Run unit tests side by side with this stage to catch issues sooner.

2. Adding Your “Brand” Configuration to Your Build

Keep a master list of your brands to spawn related build jobs. This could be part of a YAML template or a file in your repository. Pass the brand value to child jobs with an input variable in your YAML template to make sure the right brand configuration is used across the pipeline.

Here’s an example of triggering Android build jobs for different brands using YAML loops:

stages:
    - stage: Build
      jobs:
          - job: BuildAndroid
            strategy:
                matrix:
                    BrandA:
                        BrandName: 'BrandA'
                    BrandB:
                        BrandName: 'BrandB'
            steps:
                - template: templates/build-android.yml
                  parameters:
                      brandName: $(BrandName)

3. Creating a YAML Job to “Re-Brand” the Default Configuration

Replace static files specific to each brand using path-based scripts. Swap out the default logo at src/img/logo.png with the brand-specific logo at src/Configurations/Foo/img/logo.png during the build process for every brand apart from the default.

An example YAML snippet for this step would be:

jobs:
    - job: RebrandAssets
      displayName: 'Rebrand Assets'
      pool:
          vmImage: 'ubuntu-latest'
      steps:
          - script: |
                cp -R src/Configurations/$(BrandName)/img/logo.png src/img/logo.png
            displayName: 'Replacing the logo with a brand-specific one'

4. Publishing Your Branded Artifacts for Distribution

Once the pipeline jobs for each brand are complete, publish the artifacts to Azure Artifacts, app stores, or other channels. Ensure this process is repeatable for any configured brand to lessen the complexity of managing multiple releases.

In Azure, decide whether to categorize your published artifacts by platform or brand based on what suits your team better. Regardless of choice, stay consistent. Here’s how you might use YAML to publish artifacts:

- stage: Publish
  jobs:
      - job: PublishArtifacts
        pool:
            vmImage: 'ubuntu-latest'
        steps:
            - task: PublishBuildArtifacts@1
              inputs:
                  PathtoPublish: '$(Build.ArtifactStagingDirectory)'
                  ArtifactName: 'drop-$(BrandName)'
                  publishLocation: 'Container'

By implementing these steps and harnessing Azure Pipelines, you can skillfully manage and disseminate white-labeled mobile applications from a single codebase, making sure each brand maintains its identity while upholding a high standard of quality and consistency.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

Why Okta?

Who can forget Okta? It is basically a household name at many enterprise companies. Even if you don’t know about Okta, you probably recognize the name. Okta is a cloud-based identity and access management platform that provides secure user authentication and authorization services. It enables organizations to manage and control access to various software applications, systems, and data resources across multiple devices and networks.

In my opinion, the best reasons to use Okta are for multi-factor authentication (MFA) and single sign-on (SSO) functionality. It adds an additional layer of security, enables users to access multiple applications and services with a single set of credentials, eliminating the need for them to remember multiple usernames and passwords.

MFA is extremely important to secure the login flow because it adds an extra layer of verification beyond just a password, which are stolen and leaked every day through phishing and data breaches. We all love a security sidekick, but those extra authentication steps can feel exhaustive and over protective, especially if the login is happening on the same device with the same credentials.

This is where Remember Device comes in and allows users to conveniently access their accounts without the need for frequent MFA. Okta provides this functionality and has several recommended ways to implement it.

Getting Technical

Okta’s documentation provides implementation insight for the Remember Device feature. They have their own implementation, but it may be beneficial to generate your own token for the devices your users access the application from.

To achieve this, Okta exposes the “deviceToken” property that can be included in the context object of a standard authentication request. This device token serves as a unique identifier for the user’s device. Okta makes it clear that a property override is considered a highly privileged action, requiring an administrator API token. The introduction of the context object in this manner ensures Okta remembers this device token regardless of how the user proceeds through the authentication process.

This is where a problem starts to show up. Even if the user doesn’t explicitly set the “rememberDevice” query parameter as true during the MFA process, the device token will live in Okta for that user for some long unknown amount of time. Okta’s recommended approach saves the device token EVERY SINGLE TIME. Even if a user selects Do Not Remember, anyone who saves or has access to that device token can use it to bypass MFA the next time that account is logged in. This can be especially tricky when multiple users may have accounts on the same device.

In the Real World:

• 300 users login daily for 1 week
• 300 x 7 = 2100 device tokens stored in Okta per week
• Okta doesn’t provide any information on it’s threshold for storing these values
• All prior tokens are still active and can bypass MFA

Luckily, as with most technical challenges, the company responsible has already discovered a way to solve the problem. Let’s take a look at Okta’s own UI widget they provide for login and MFA.

Okta Uses Cookies 

When authenticating through Okta’s widget, the same issue does not occur. If you take the device token generated on login, don’t select “remember device” and try to force that same token on a subsequent login, Okta treats it as a new device token. What is Okta’s widget doing that it’s documentation is hiding from us?

Okta uses the Device Token (DT) cookie as a secure token that is stored on a user’s device after successful authentication. It serves as a form of identification for the device and allows Okta to recognize and trust that device for future login attempts.

This cookie is used by their system to store during an MFA call if the rememberDevice query parameter is true. If that parameter is not true, then Okta will NOT save that token. When integrating with Okta through a custom backend service, if you really want to ensure that the device tokens you generate are not being maintained by Okta, then you will need to set the DT cookie value instead of the context object.

This is not a privileged action, it doesn’t save the device token. Okta even conveniently provides their own device token using that cookie if one is not passed in through the context object or the DT cookie on the initial authentication request.

What’s the Catch?

Unfortunately, this solution only works for Okta integration into a back-end service. Due to the updated Fetch spec, browsers block any JavaScript from accessing the “Set-Cookie” headers.

The only way to approach custom device token generation from a JavaScript front-end, is by using the context object and ensuring that each token generated is unique per user per device.

Conclusion

Okta still provides one of the strongest authentication systems in the tech industry and it will likely be around for a long time. If you want to have a more custom experience and generate your own tokens, keep in mind the issues that can arise from using Okta’s recommended approach. With a backend service, we can work around these issues and ensure we create only a single device token per user upon request. If your solution does not require customization, we recommend the Okta widget that already has the proper device token management built in.

This way Okta will only remember you the way you want them to.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

Considering the growing importance of mobile and web applications, choosing a QA Test Repository for your organization can be a daunting task with the options available on the market.  It can be difficult to determine where to start when evaluating tools and options. We can help jumpstart that process! Let’s dig into the benefits and drawbacks of four popular test case repositories: X-Ray, TestLink, TestRail and Zephyr. These tools play a vital role in QA test case creation, execution, and reporting regardless of team size. 

Recommendations 

For Large Teams: Zephyr or X-Ray

• Key Features:
  • Customizable workflows
  • Keeps team members in sync
• Reasoning:
  • Zephyr is recommended for large teams due to its customization features, ensuring alignment in workflows and promoting team collaboration.
  • X-ray is a suitable choice for larger teams already using Jira, offering seamless integration and a comprehensive testing solution.

For Teams of Any Size: TestRail

• Key Features:
  • Simple user interface
  • Easy to learn
• Reasoning:
  • TestRail is recommended for teams of any size due to its user-friendly interface, making it easy for both small and medium-sized teams to adopt.

For Small Teams: TestLink

• Key Features:
  • Affordability
• Reasoning:
  • TestLink is a budget-friendly option, making it well-suited for small and medium-sized teams with budget constraints.

In the realm of mobile testing where a wide range of devices and operating systems presents its set of challenges, having a strong and extensive collection of test cases is incredibly important. A structured and comprehensive test case repository forms the foundation of mobile testing strategies. It acts as a hub simplifying test case management promoting teamwork and cooperation, among team members and maintaining uniformity, in testing processes across mobile platforms.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

Accessibility testing on Websites and apps with automated accessibility scanner tools are a great help but they only get you so far.  Screen Readers will bridge the gap in your accessibility goals to reach your user base spanning various impairments.

Using Screen Readers

Text-to-Speech Screen Reader technology (generally referred to as simply “Screen Readers”) can be used to help people who are blind or otherwise visually impaired to use and enjoy websites and applications. Onscreen content and instructions can be read aloud by the screen reader software so that the user is able to read, navigate, and access the content and functionality available to sighted users.

Because most Screen Reader users don’t use a mouse, a variety of either keyboard commands (for desktop/laptop computers) or touch commands (for mobile handheld devices) are available to users. Here, we’ll focus on some of these commands for using mobile Screen Readers.

For developers, setting up your website or application for a good Screen Reader experience, using modern, valid HTML will get you most of the way there – but to optimize the experience your code will need to be configured.

Additional Code Elements Include:

• Accessibility Identifiers: Mobile element identification id that allows for easy traversal of screen elements. Eliminates possible XPath errors and can allow be used for QA Automation
• “alt” attributes for images: these attributes are applied to HTML tags, and are best used to provide concise descriptions of images on the screen
• ARIA attributes:
  
  • “aria-label”: used to provide additional description, often used for interactive elements that don’t have an accessible name (e.g. icons)
  • “role”: used to describe elements that don’t natively exist in HTML, or elements that do exist but don’t yet have full browser support
  • Various state and property aria attributes (e.g. https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques)
• Headers (h1-h6): used properly, these form a sort of outline of the content of a page
• Landmarks: a way to identify the various regions of a page (e.g. navigation, main content, etc.)

The two most widely used mobile screen readers are VoiceOver (iOS) and TalkBalk (Android). 

Users need to learn a set of touch gestures to use these mobile screen readers. The most basic gestures used are tapping to select items, and swiping right or left to respectively select the next or previous item to interact with on the webpage. As items are selected, their onscreen text and perhaps other information will be spoken by the screen reader voice.

Just as a sighted user can visually scan pages displayed on the screen to more quickly get to the info or functionality they want, screen reader users can navigate using these multi-finger gestures in a similar fashion. These users are not locked into going though all the content in sequence. There are additional gestures available to users to perform more complex interactions.

VoiceOver

VoiceOver provides the ability to traverse page elements with gestures, keystrokes, and Voice Recognition. It also supports braille displays – users can connect a Bluetooth^® wireless braille display to read the output if they prefer that to the voice output.

VoiceOver offers a wider range of gestures beyond the basic swiping/tapping gestures. 

Additional VoiceOver Gestures:

• Mute/Unmute VoiceOver: Three-finger double-tap
• Use a standard gesture: Double-tap and hold your finger on the screen until you hear three rising tones, then make the gesture. When you lift your finger, VoiceOver gestures resume.
• Open the Item Chooser: Two-finger triple tap
• Rotor: Initiated by using an onscreen two-finger rotation – among other multi-finger gestures to change page
• “Magic Tap”: Two-finger double tap; this is the only gesture that can be programmed to perform different actions in different apps

Full gesture list for VoiceOver: https://support.apple.com/guide/iphone/learn-voiceover-gestures-iph3e2e2281/ios

TalkBack

TalkBack also provides eyes-free navigation and control of applications, allowing users to use gestures and voice commands. It also supports braille also – including an on-device keyboard for typing braille so users that wish to type with braille don’t need to connect to their physical braille keyboard.

Additional TalkBack Gestures:

• Mute/Unmute TalkBack: Three-finger double tap
• Explore by touch: Drag a finger on the screen to hear the item below your finger spoken
• Magnification settings: Triple tap
• Move to the next/previous reading control: 3-finger swipe down/up, respectively

Full gesture list for TalkBack: https://support.google.com/accessibility/android/answer/6151827?hl=en

The use of Screen Readers can greatly benefit your accessibility testing efforts to ensure you are reaching as much of your user base as possible. This empowers users to skip pages, control video, dismiss alerts and even mute the screen reader voice, all with touch gestures! So consider adding Screen Reader support to bolster your accessibility testing efforts.

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

In today’s rapidly evolving mobile landscape, ensuring the quality and reliability of mobile applications is paramount. As the number of mobile devices and platforms continues to grow, manual testing alone becomes increasingly challenging. This is where mobile QA automation steps in, offering a powerful solution to streamline testing processes, improve efficiency, and enhance overall product quality. By leveraging automation tools, frameworks, and techniques specifically designed for mobile applications, organizations can effectively validate their mobile software across diverse devices, operating systems, and scenarios. We’re sitting down with two of Perficient’s mobile QA automation experts to discuss how to answer your frequently asked questions about getting started with QA automation.

Meet Perficient’s Mobile QA Automation Experts

Heena Grover is a lead technical consultant in Perficient’s mobile solutions group. She has over 15 years of experience working with mobile QA and managing QA automation teams.

Abhigna Bheemu is a lead technical consultant in Perficient’s mobile solutions group. She has over 13 years of experience with mobile development and has worked with QA automation for 5 years.

Frequently Asked Questions about Mobile QA Automation

I’m interested in setting up QA automation for my Flutter iOS and Android mobile apps, how do I get started?

Heena: First, it is important to have a deep understanding of the project requirements and the capabilities of your development team.

Abhigna: If you’re still in the design phase, you will want to start with the wire frames, design a framework reference the Mobile QA Automation Cheat Sheet.

Glossary of QA Automation Operations

• Test Case – Collection of steps to test application features
• Test Script – Test Case coded in specified programming language for solution
• Test Suite – Collection of Test Cases
• Test Case Repository – Collection of object identifiers
• Test Execution – Using a tool to run Test Cases or a Test Suite
• Open Source – Publicly available source code available for possible modification and redistribution
• Code-Based – Writing code explicitly using Selenium, Cypress, or any other tool for testing
• Code-Less –  Drag and drop UI interface and possibly BDD language to write tests in English
• Cloud-based – Any software program or application that’s stored, managed, and available through the cloud accessible via authentication credentials

Mobile QA Automation Cheat Sheet

Step	Tool
1. Develop a relationship and meeting cadence with your Product Owner, Business Analyst and Dev team
2. List out feature candidates for QA Automation Test Cases on regular basis
3. Do a Proof of Concept to determine tools and framework to assess compatibility with the mobile app
4. Select the programming language	Java
	JavaScript
	C#
	Python
5. Select the Framework	Cucumber
	Page Object Model (POM)
	Data Driven Framework
6. Cloud Platforms for Device Emulation, Testing and Reporting	BrowserStack
	SauceLabs
	Perfecto
	AWS Device Farm
	pCloudy
7. Install tools and external libraries for the programming language and framework choices above

 8. Select the Tools – There are a number of options that can suit your needs whether it’s open source or closed/cloud-based

Code-Based	Open Source	Code-Less
Appium	Yes	-
Selenium	Yes	-
WebdriverIO	Yes	-
Eggplant	Yes	-
SeeTest	No	Applitools
TestComplete	No	Katalon Studio
Ranorex	No	Ranorex Studio
-	No	Perfecto
-	No	AccelQ
-	No	Sofy.ai
-	No	Kobiton - Scriptless Test Automation
-	No	Waldo

I have a MacBook, will I need additional hardware to set this up?

Abhigna: No, you don’t need additional hardware.

Heena:  Mobile automation is more reliable and covers cases for iOS and Android on a MacBook, so you don’t need additional hardware.

Will I need to learn any specific coding techniques to write test cases?

Heena: Once you have decided what language you’re going to use with the framework you definitely need to understand the basics and you need to learn how to use that language. There are so many languages in the market, so if you are starting from scratch and you’re just building your career in automation there are many options available. Reference the Cheat Sheet.

Abhigna: You have options between Code-Based and Code-Less tools, depends on project preference and resource availability.

Do accessibility identifiers make automation easier?

Abhigna: Yes, the accessibility identifiers are the thing we use to uniquely identify an object. So if identifiers are good, automation will go smoothly.

Heena: Basically, you don’t have to overuse the XPath (the locator of an element on an app page) so it is better to use accessibility identifiers.

What is the best way to track accessibility identifiers?

Abhigna: We create and maintain an object repository (Spreadsheet, Class files, Constants files) based on the framework we design. This helps automation engineers to understand rules for how to create and reuse these identifiers.

Heena: We can put these into user stories as new features are developed. If we have a solid framework in place then each story should have these checks. QA engineers can create a YAML file which will server as a living document.

How do I get the best results with automated test runs?

Abhigna: You’ll get the best results when integrated with the developers’ pipeline and with every build executed. If you integrate with the pipeline as soon as the developer pushes the build to QA, the scripts will trigger and generate results.

Heena: If you know you have pipelines ready and we have all our test suites set up in a way that we know when they will run, this is the best practice. The benefit of this is that if one test fails it does not fail all of the test cases. There are multiple ways to do test runs in automation and get the maximum results. I’d also recommend dividing test cases into multiple threads to test out specific features or flows to allow for more flexibility.

Can I leverage a Cloud Platform and what are my options?

Abhigna: There are number of options that can integrate with our framework to leverage the device emulation and reporting features. Integration instructions are available in any cloud platform site. Please refer to the Cheat Sheet.

Heena: It’s important to include a Cloud Platform. You can’t always rely on a physical device. If you want your automated pipelines to run on repository commits, Cloud is required.

What kind of reports are available?

Abhigna: Based on the framework we select, we can generate CSV, XLS, XML or HTML reports automatically, but we can always alter them to suit our needs.

Heena: The reports will be pass fail with the test case titles and reason for failures. For example, you have a suite of 10 Test Scenarios. Reports can give you granular information about each test and show why it passed or failed.

What factors impact cost?

Abhigna: The cost depends on tools, resources and timelines.

Heena: We will also want to consider what we want to include in the reports because each feature has an additional cost. For example, we want a report of a past run, and if you want to add which scenarios failed, and you want to add logs, that will drive up the cost.

Are there any free tools I can leverage?

Abhigna: There are a lot of free tools available, and most people are efficiently using them.

We generally use the following:

• • • • Language: Java
      • Framework: Cucumber
      • Tools: Appium, Selenium

Heena: I agree, the tools Abhigna mentioned are the standard industry toolset.

What happens to test executions if I have to re-platform?

Abhigna: You can reuse test executions and test cases if you decide to re-platform. The coding will be the same, but the object identifiers will differ. You could build a repository for them and write a framework to select the appropriate objects so you don’t need to re-write scripts. If you plan the initial setup properly, then everything will go smoothly.

Heena: You can classify your identifiers whether you’re using a web identifier or native identifier. It all depends on what your developer is plugging into. For example, if they’re using native code from iOS they will need to use a native identifier and you can define that in your code.

What resources can I review to get more information on QA automation?

Heena: There are many QA resources available:

• Appium Mobile Automation Testing from Scratch + Frameworks Tutorial
• Appium – Mobile Testing with Latest 2.0 and Live Projects
• Appium Android: Easy Guide to Mobile Automation Testing Dev

Abhigna: There are some great videos and learning materials:

• App & Browser Testing Made Easy
• Setting up your own test automation environment

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!

The 2023 Google I/O conference has come and gone, and as always, there’s a lot to unpack. Android users in particular have reason to be excited, as Google announced some exciting updates to the world’s most popular mobile operating system. From new features to major design changes, there’s a lot to uncover. So, without further ado, let’s dive into what’s new in Android from the 2023 Google I/O conference.

Meet the Perficient Android Development Experts

Jeff Small is the Director of  Mobile Solutions group. Jeff has 15+ years of experience building successful mobile products in Android and iOS.

Garrett Manley is a Lead Technical Consultant in Perficient’s Mobile Solutions group and has over 8 years of experience in mobile development. He is an expert in cross-platform application development, he specializes in enterprise mobile applications and has a comprehensive understanding of the full mobile development lifecycle. With a passion for front-end technologies and an eye for design, Garrett ensures seamless integration of aesthetics and functionality in his projects.

Vipul Panchal is a Senior Technical Architect in Perficient’s Mobile Solutions group with 11+ years of experience with cross platform mobile applications for Android and iOS. Vipul helps create a technical vision with his broad range of digital experience in both mobile and web technologies.

Dan Wilkerson is a Senior Mobile Architect in Perficient’s Mobile Solutions group, working across multiple industries. He is passionate about mobile development with 12+ years of experience developing mobile applications for iOS and Android.

What are your overall impressions of the new Android features and capabilities presented in the keynote?

Jeff: My biggest takeaway from this year’s Google I/O was that Google is integrating generative AI and Machine Learning into basically all of their products. You can already see the effect Chat GPT’s popularity is having on these tech companies. It’s becoming a race to make sure everything has AI and ML embedded in some way.

Dan: As someone who works with a lot of clients in the automotive industry, I was very interested in the updates to Android Auto. It’s hard not to compare it with CarPlay, but with the recently announced updates, they are getting very close to offering the same features and capabilities. Big picture, I think we are going to see a lot more vehicle data that users will be interacting with.

Vipul: I was excited to see the improved debugging capabilities with Android 14 ML kit. If I’m in React Native, or even previous versions of native Android, there are limitations to what I can do, and I am relying heavily on Javascript. With this update, Android 14 supports Jetpack and significantly increases debugging capabilities for native development.

Garrett: What stood out to me first, and foremost, was the AI they are implementing into all of their feature sets and their emphasis on responsibility around AI tools. We’ve seen these questions come up with OpenAi, and Google has been able to provide a plan on how they will address these very real concerns regarding AI. Also their investment in cross-platform development, with Jetpack compose they are really pushing a whole new development stack to modernize the Android apps.

How do you think these new features will impact your development process?

Garrett: A big thing we are seeing with Android is they are really leaning into this open screen world across their devices and they’re unifying those APIs for handling those UI layouts across screens. They’ve unified those APIs and built new ones in compose to make those layouts available and easier to work with.

Jeff: I’m excited to see the impact of generative artificial intelligence on developer support. The new AI-powered features and capabilities of developer tools should usher in a new era of speed, reliability and quality of code among developers.

Vipul: Two of the new changes caught my eye. With the new credential manager feature, a user can now use the passkeys to authenticate into the app. It will also support other passkey providers and developers will have to invest in supporting this new capability along with the existing password mechanism. App developers will also have to adjust the new media access permissions that were displayed in developer preview.

Dan: I think the AI tools embedded in the IDE are going to be huge boost in productivity in all facets of development, testing, and deployment.

Are you anticipating any challenges or drawbacks to these new features?

Vipul: There’s a new feature where you can duplicate an app on your device so that two people can log in and use their version of the app with two separate instances of the application environment where users can be authenticated. This could be challenging for developers to manage.

Dan: I do not anticipate significant challenges or drawbacks; however, there will certainly be some pain-points as teams adapt to the new tools and modified workflows.

In your opinion, which industry will benefit the most from these updates?

Jeff: For me, it’s healthcare and mHealth. They gave an example of a new glucose monitoring capability in Android Health and I was just blown away by the idea that you could have a glucose monitoring device integrated with Android Health that connects to your MyFitness Pal that would be able to track and manage glucose levels in conjunction with your diet. We are going to continue to see multiple apps connected to Android Health through improved APIs sharing data and creating a more holistic overview of personal health.

Dan: I have to say I’m super excited about the new automotive capabilities and I think that’s going to have a huge impact on the industry. We are trending toward having a lot more communication in your car and a lot more control over the vehicles. Google has upped the ante to compete with Apple and I think that will be huge for the industry.

Vipul: Google has made a big investment in AI, and I think we are going to see that have a huge impact on manufacturing. With manufacturing, you’re going to see more companies using the improved ML kit for scanning parts and managing inventory, like we are already seeing with some retail companies, helping to increase efficiency.

Garrett: I also think healthcare will see the biggest impact, but with peripheral devices. There are a lot of capabilities that were talked about here that will allow you to get snippets of data that used to be too risky to share outside of a direct app. So there’s going to be a lot more interoperability that allows for more innovation in the device market.

How do you think these new features compare to updates from other operating systems?

Jeff: I think that there is greater parity now between mobile operating system experiences. The shared experiences across devices, autos, phones, and wearables are becoming more and more “standardized’ as users leverage experiences across devices and platforms. This is great for users, and I believe it’ll lead to greater and faster adoption across these experiences. Health management, for instance, I believe will grow by leaps and bounds because of this rise in parity of experience.

Vipul: New credential manager, the BARD API and other generated AI improvements are significant, and they stand out directly compared to others.

Dan: There are a lot of similarities between the features announced by Google and those existing or recently announced by Apple.  I think the striking difference for me is Google going all-in on the integration of AI across the board.

In Conclusion

All in all, the 2023 Google I/O conference brought some major changes and updates to the Android ecosystem. We saw new features such as the customizable gesture controls and the improved split-screen mode, as well as major design updates such as the new Material You design language. Google also announced new privacy features to give users more control over their data and an expansion of the Android Auto experience to more countries. With these updates, Android continues to evolve and improve making it an even more powerful and user-friendly mobile operating system. We can’t wait to see what the future holds for Android, and we’ll be sure to keep you updated on any new developments.

For more information on Perficient’s Mobile Solutions expertise, subscribe to our blog or contact us today!

Want to Tantalize your Audience with an Amuse-Bouche of your Mobile App?

Wait, what’s an amuse-bouche?

It’s a single-bite appetizer that translates to “mouth amuser.” It serves as an incredible preview of what’s to come in your course meal.

Apple App Clips and Google Instant Apps can serve as your digital amuse-bouche. It can serve a target audience of casual customers who may or may not be aware of all the great features your app provides. App Clips and Instant Apps provide the perfect vehicle for just that. They gives you the chance to dazzle customers with a great user experience they won’t be able to deny. This technology provides a perfect teaser to convert casual users to full-fledged app users who will start interacting with your brand at a deeper level.

Apple App Clips

An App Clip is a bite-sized taste of a brand experience curated in your app. Apple App Clips can provide quick, convenient functionality that achieves a customer goal. This functionality provides users the convenience of interacting with your brand in a quick, convenient way.

The ultimate goal is to retain the new user and have them install your full app. In the event a new customer installs the full app, every App Clip invocation will launch the full app.

Minimum OS: iOS 14+

Invocation:

• URL
• QR Code
• NFC
• Safari App Banners
• Apple Maps Place Cards
• iMessage Links
• App Clips app

Size Limit: < 10 Mb

Number of Instances: 1 App Clip per iOS Application. Can customize experience to have multiple entry points.

Installation: App Clips are downloaded and installed within the App Clips app. They are automatically deleted after 30 days of inactivity.

Case Study: Panera has done a great job illustrating the power and convenience of App Clips. The App Clip appears in Apple Maps search for Panera locations. Upon selecting your nearest location, you see a detail card with an Order button. Tapping the Order button initiates the lightning fast App Clip experience. The user sees the App Clip poster card which allows them to open. From there they see the full menu with option to pick-up In-Cafe or Curbside. The full guest cart experience is available including payment with Apple Pay or Google Pay. No download required and no personal information input since that data conveniently comes along the ride with Apple Pay or Google Pay. This lightweight experience can get your lunch ready to go in a very short amount of time.

Panera is one successful real world implementation of App Clips. It opens up the world of micro experiences in physical locations or via URL to provide a useful experience to reach new app users. Guest experiences that provide useful features to customers are great ideations of the App Clips and Instant Apps approach.

Google Instant Apps

Google Play provides the ability to launch tiny native apps without being installed. These experiences are called Instant Apps and Instant Games. Google Instant Apps provide the user a micro experience to motivate users to install the full app.

Instant experiences fall into two categories: “Try” experiences in the Play Store and “Instant play” games in the Google Play Games app.

Google Play only sends the files needs to run the app or game to the Android device when a user initiates the request to run the instant experience.

Minimum OS: Android 5.0 (API Level 21)

Invocation:

• Google Play Store App Download Screen
• URL
• QR Code
• NFC
• Website Banners

Size Limit: < 15 Mb

Number of Instances: 1 Instant App per Android Application. Can customize experience to have multiple entry points.

Installation: Installation required to run Instant Apps. They can be removed from the Settings.Google.Instant Apps option.

Case Study: Buzzfeed offers an Instant App glimpse into their experience touting quizzes and recipes and videos via the Try Now button on the Google Play Store. This allows prospective users a taste of what the full app can offer without the overhead and download time.

Why Use App Clips and Instant Apps?

App Clips and Instant Apps provide the opportunity to showcase the strengths of your customer experience that can potentially convert casual customers into app users. The trick is to focus on micro experiences and do them well to surprise and delight users to spark their interest in learning more about what your full apps can do for them. In other words, a single tasty bite.

Why not give them a try?

For more information about Perficient’s Mobile Solutions expertise, subscribe to our blog or contact our Mobile Solutions team today!