top of page
  • Writer's pictureSofia Ng

Custom App Development on Make

Updated: May 1

Make offers a practical and accessible platform for both seasoned developers and novices to create custom apps. With its flexible environment, users can develop apps that integrate with services like Microsoft Graph API and Dataverse, enhancing their digital workflows and creating your own.

Advantages of Using Make

For anyone diving into the world of app development, whether a seasoned coder or a budding entrepreneur, Make presents an enticing proposition. The depth of customisation available allows developers to create complex, highly functional apps using custom connectors, remote procedure calls and IML functions.

These tools give you the option to go beyond the surface of no-code interfaces, adding layers of functionality that can cater to sophisticated operational needs. This capability is especially beneficial when you need to integrate advanced data manipulation directly within your apps, making Make not just budget-friendly but also incredibly powerful.

Real-World Application Examples

A practical example of Make's capability is its use in automating tasks like assigning and removing licenses for new employees via the Microsoft Graph API. This process is part of a larger onboarding/offboarding system that significantly eases the onboarding and offboarding workflow. The ability to automate these functions means that what once took hours now happens instantly, with minimal human intervention.

In one instance, the setup involved using Make to automatically trigger actions within Microsoft’s software ecosystem whenever new employees were finalised in the payroll system. By automating onboarding and offboarding tasks, companies can reduce the administrative burden and minimise the chance of human error, ensuring that new hires have the tools they need from day one without delays.

Step-by-Step Guide to Building Your First App on Make

Creating your first app on Make can seem daunting, but once you get in the swing of things it's really quite fun. Here’s how you can start:


Begin by gathering all necessary API documentation for the APIs you intend to use. Make sure you can test these using a tool like Postman. This step is important as troubleshooting issues directly in Make can be challenging without a clear understanding of the API's behavior.

Authentication Testing

Ensure your authentication methods are tested in Postman. This ensures that you have all the necessary credentials and that they are working correctly, which is critical for the next steps. Make sure you know what type of authentication is used, i.e. OAuth2, API Key etc.

App Creation Basics

Navigate to the 'My Apps' section in Make. Here, you will start by setting up your app’s metadata:

Name: A unique identifier for your custom app.

Label: A user-friendly name that will appear in the scenario editor.

Description: A brief description of what your app does (optional).

Theme: Choose a color theme that will be used for your app’s modules.

Language and Audience: Set the default language and specify the audience by geographic location. It is good practice to set the regions where your app should be accessible from.

Base Configuration

The 'Base' is essentially the backbone of your custom app. It contains settings that are common across all modules and procedures within your app. This includes configurations for how your app will connect to and interact with external APIs.

  • Base URL: This is the primary URL for the API with which your app will interact. It serves as the starting point for all requests made by the modules in your app. For instance, if you are integrating with Dataverse your base URL might look something like: https://{org}

  • Authorisation: Depending on the external API’s requirements, you might need to set up specific authentication methods such as OAuth, API keys, or basic authentication. Make sure that this is configured to maintain secure connections.

  • Error Handling: Specify how your app should respond to different errors encountered during API calls. Effective error handling is critical for maintaining the stability of your app under various conditions.

  • Sanitisation: This setting helps ensure that any sensitive data, like authorisation headers, are properly managed to prevent unintended exposure.

Connection Configuration

The connection configuration enables your app to securely communicate with external services. There are several authentication methods available on Make.

The most commonly used are:

OAuth 2.0: For services that require specific user permissions and secure, token-based access.

API Key: When you have a unique key that grants you access to an API.

Basic Auth: For APIs that require a simple username and password combination.

Once the connection type is selected, you generally need to modify the pre-existing template with the appropriate URLs and parameters names that correspond to your API's specifications.

Working through a Connection Example

Consider a scenario where your app needs to fetch a list of books from an API, and this action requires an API key for authorisation. Attempting to access the endpoint /books without the key results in an error. Here’s how you would set up a connection to authorise requests:

  1. Create a New Connection: Navigate to the 'Connections' tab and click to create a new connection. Name your connection and select the type—'API Key' in this case.

  2. Define the Communication: The communication object will include the URL for a test request and the place where your API Key will be used.

  1. Parameterise and Sanitise: Ensure that the API key can be parameterised, allowing each user of your module to enter their unique key. Also, ensure that sensitive information, like the API key, is sanitised from logs to prevent exposure.

Module Setup

Modules in Make act as the functional units of your app, each designed to handle specific tasks or interactions with the API. Setting up modules correctly is key to creating a robust custom app.

Module Types

Make supports various types of modules, including Actions, Searches, and Triggers (polling). Actions are used for sending data to your API, Searches retrieve data, and Triggers watch for specific changes in your API to initiate workflows.

Creating a Module

To create a new module, navigate to the Modules section under your app settings. You'll need to provide:

Name and Description: Clearly describe what the module does, making it easier for users to understand its functionality.

Connection: This is where you select your created connection.

Endpoint Configuration: Each module will correspond to a specific endpoint in the API. For example, if your module is designed to retrieve user data, you might configure it to hit an endpoint like /users/{userId}. The URL should start with / as this is relative to the base URL configured in the base at the start in the section Base Configuration.

Parameter Mapping: Define which parameters your module will accept and how these map to the API’s expectations. This is crucial for ensuring that the data flows correctly between Make and the external API.

Testing and Validation: Once you have configured a module, it’s important to test it to ensure it interacts correctly with the API. Check for proper data retrieval, error handling, and that all parameters are correctly passed.

Below is an example retrieving contacts where the last name is equal to the parameter passed.

This is the simplest form of parameter but there are many other options available. Link to parameter documentation.

And there you have it—a quick step through building your custom app on Make, a platform where flexibility meets functionality. Whether you’re integrating complex systems or automating simple tasks, Make's accessible tools open up a world of possibilities for both the tech-savvy and the tech-curious alike.

In the next post about Make we will go through how to create a custom app using the VS code plugin.

Recent Posts

See All


bottom of page