top of page
Logo of top retool developers and retool agency

Building Internal Software with Retool Utilities

Retool is a robust platform for swiftly and effectively developing internal software. It offers a drag-and-drop interface, enabling users to design custom applications by integrating different data sources, APIs, and services. With Retool, you can create intricate internal tools without requiring extensive coding knowledge, thus making them accessible to an organization's wide range of users.


Leveraging Retool for Internal Tool Development


Leveraging Retool for Internal Tool Development

Speed and Efficiency: Retool accelerates development by providing pre-built components and easily customizable templates. It significantly reduces the time and effort required to build functional internal tools.

Integration Capabilities: Retool supports seamless integration with numerous data sources, including databases like PostgreSQL, MySQL, MongoDB, APIs, and third-party services like Stripe and Twilio. This flexibility allows you to consolidate data from various sources into a single interface.

Customization and Flexibility: While Retool offers an intuitive drag-and-drop interface, it also allows for custom JavaScript and SQL queries, providing advanced users the flexibility to add complex logic and functionality to their applications.

Collaboration and Version Control: Retool supports team collaboration with features like version control and role-based access controls. It ensures that multiple team members can work on the same project simultaneously without conflicts.

Security: Retool includes built-in security features such as encryption, audit logs, and SSO integration to ensure your internal tools are secure and compliant with organizational policies.

Scalability: Whether you are a small startup or a large enterprise, Retool scales with your needs, making it a versatile choice for businesses of all sizes.


For more detailed information, you can visit Retool's official website.


The next step is to set up your Retool account and activate the utilities. Follow the guidance in the following section.


Setting Up Your Retool Account


Here is the step-by-step guide on setting up your Retool account.


Step 1: Visit Retool's Website

Step 2: Start the Signup Process

  • Click on the “Get Started for Free” button on the homepage. It will redirect you to the signup page.

Step 3: Provide Your Information

  • Fill in your email address and create a password. You can also sign up using your Google or GitHub account for quicker access.

Step 4: Confirm Your Email

  • If you signed up using an email address, check your inbox for a confirmation email from Retool. Click the confirmation link to verify your account.

Step 5: Complete Your Profile

  • Once your email is confirmed, you must complete your profile by providing additional details such as your name, company, and role.

Step 6: Set Up Your Workspace

  • Create a workspace for your team. Enter a name for your workspace and invite team members by adding their email addresses. If you prefer, skip this step and add team members later.

Step 7: Explore Retool

  • After setting up your workspace, you can explore Retool’s features and build your first application.


Overview of Retool's Dashboard and Key Features


Dashboard Overview

  • Home Screen: The dashboard displays recent projects, applications, and key metrics. It provides a quick overview of your workspace activity.

  • Navigation Sidebar: The sidebar on the left-hand side of the dashboard allows you to navigate between different sections, such as Applications, Resources, Queries, and Settings.


Key Features

  • Drag-and-Drop Interface: Retool offers an intuitive drag-and-drop interface that simplifies building custom applications without extensive coding knowledge.

  • Pre-Built Components: Access a library of pre-built components, such as tables, forms, charts, and buttons. You can customize these components to fit your specific needs.

  • Data Source Integration: Connect to a wide range of data sources, including SQL databases (PostgreSQL, MySQL), NoSQL databases (MongoDB), REST APIs, GraphQL, and third-party services such as Stripe, Twilio, and more.

  • Custom JavaScript and SQL: For advanced users, Retool allows the addition of custom JavaScript and SQL queries to enhance the functionality of your applications.

  • Version Control: Implement version control to track changes, manage revisions, and collaborate efficiently with your team.

  • Role-Based Access Control: Manage permissions and access levels for different team members to ensure security and compliance.

  • Collaboration Tools: Retool supports real-time collaboration, allowing multiple users to simultaneously work on the same project.

  • Deploy and Scale: Deploy your applications to different environments (development, staging, production) and scale them as your business grows.


Now that you have set up your Retool account, the following section will guide you through creating a new Retool resource.


Creating a New Retool Utilities Resource


This section will give you a clear understanding of creating a new Retool resource.


Understanding What is Resource  in Retool


In Retool, a resource is a set of configurations that defines how Retool connects to a specific data source. These configurations can include authentication credentials, database connection settings, and API settings. Resources bridge your Retool applications and your data, enabling seamless interactions and integrations across various platforms such as SQL databases and REST APIs. You also refer to resources and tutorials to understand them better.


Guide on Creating a REST API Resource in Retool


Step-by-Step Guide:


Creating a REST API Resource in Retool

Navigate to the Resources Tab:

  • From the Retool homepage, go to the "Resources" tab.

  • Click "Create new" and select "Resource."


Select REST API:

  • Choose "REST API" as the resource you want to create.


Configure the Resource:

  • Name Your Resource: Give your resource a meaningful name.

  • Base URL: Enter the base URL of your REST API.

  • Headers: If necessary, add any default headers that your API requires.

  • Authentication: Configure the authentication method as needed.


Save the Resource:

  • Once you have set all configurations, click "Create resource" to save your settings.


Configuring Authentication for the Resource


Retool supports various authentication methods for connecting to your data sources. Common methods include:


  • Basic Authentication: Use a username and password.

  • Bearer Token: Use an access token.

  • OAuth 2.0: For APIs that require OAuth, you will need to configure the OAuth client credentials, including the Client ID, Client Secret, Authorization URL, and Access Token URL​. Refer to resource 1  and resource 2 for additional help.


Setting Up API Endpoints and Credentials


Once your resource is created and authenticated, you can set up specific API endpoints within your queries.


Step-by-Step Guide:


Create a Query:

  • In your Retool app, navigate to the query editor.

  • Select the REST API resource you just created.


Configure the Endpoint:

  • Set the HTTP method (GET, POST, etc.).

  • Specify the endpoint path (e.g., /users for a user management API).


Add Parameters and Headers:

  • Include any required parameters or headers specific to the endpoint.


Run and Test:

  • Execute the query to ensure it returns the expected data. Based on the API's response, adjust configurations as needed.


For more detailed information on creating and configuring resources in Retool, visit Retool's official documentation and their comprehensive guide on connecting REST APIs.


The next step is to learn how to integrate external APIs into Retool from the following section.


Integrating External APIs into Retool


Follow this section for the step-by-step guide on integrating the external APIs into Retool.


Examples of External APIs to Integrate


Retool allows you to integrate various external APIs to enhance the functionality of your applications. Here are some examples:


  • ApyHub APIs: Offers utility services like data validation, document generation, and more.

  • Stripe API: You can use this to manage online payments and financial transactions.

  • Twilio API: This is for sending SMS and making voice calls.

  • GitHub API: You can access GitHub repositories and user data.

  • Google Maps API: For embedding maps and location-based services.


Creating and Configuring API Resources for Utility Services


Step-by-Step Guide to Creating a REST API Resource in Retool:


Navigate to Resources:

  • From the Retool dashboard, go to the "Resources" tab.

  • Click "Create new" and select "Resource".


Select REST API:

  • Choose "REST API" as the resource you want to create.


Configure the Resource:

  • Name: Give your resource a meaningful name.

  • Base URL: Enter the base URL of the API you want to connect to (e.g., https://api.apyhub.com).


Add Default Headers (if necessary):

  • Specify any headers the API requires, such as Content-Type: application/json or authentication tokens.


Create Resource:

  • Click "Create resource" to save your settings.


Setting Up Configurations Such as Base URL, Headers, and Body Parameters


Configuring the API Resource:


Base URL:

In the resource configuration, set the base URL. This URL serves as the root endpoint for all API requests.


Headers:

In the resource configuration, you can add default headers that will be included in all requests using this resource. For example:


{

  "Authorization": "Bearer YOUR_API_KEY",

  "Content-Type": "application/json"

}


   3.  Body Parameters:

  • Specify the body parameters based on the API requirements when configuring a query. Retool supports various body formats, including JSON, raw, form-data, and x-www-form-urlencoded.

  • For example, to send a JSON body.

{

  "key1": "value1",

  "key2": "value2"

}


Following these steps, you can effectively integrate and configure external APIs within Retool, enhancing your internal tools with powerful external functionalities. 


Now, move on to creating and building applications using the Retool utilities.


Designing and Building Applications in Retool


Retool is a powerful platform for quickly and efficiently building custom internal applications. It offers a user-friendly drag-and-drop interface and integrates various data sources, APIs, and services. Retool simplifies the process with pre-built components and a flexible query editor if you need admin panels, dashboards, or other internal tools.


Steps to Create a New Application Within Retool


Creating a new application in Retool is a straightforward process. Here’s how you can get started:


Sign In: Log into your Retool account. If you don't have an account, you can sign up at Retool.


Create a New App:

  • Click the “Create new” button from the Retool dashboard and select “App.”

  • Provide a name for your app and choose the appropriate folder for the organization.


Connect Data Sources:

  • Create resources to set up the data sources your app will need. These can include databases, APIs, or other services.

  • Configure each resource with the necessary credentials and settings (e.g., database connection strings or API keys).


Assemble the UI:

  • Use the drag-and-drop interface to add components to your canvas. Retool offers various elements, such as tables, forms, charts, and buttons.

  • Arrange these components to create a user-friendly layout.


Add Queries:

  • Create queries to interact with your data sources. These queries can be written in SQL, JavaScript, or other supported query languages.

  • Bind these queries to UI components to display data dynamically.


Configure Events:

  • Set up event handlers to trigger actions based on user interactions (e.g., button clicks or data updates).


Test and Deploy:

  • Test your app thoroughly to ensure it works as expected.

  • Once satisfied, deploy your app to make it available to your users.


Utilizing the Query Editor for Setting Up API Calls


The query editor in Retool allows you to interact with your data sources through various queries. Here’s how to set up an API call:


Create a Query:

  • Open the query editor by selecting a component or creating a new query from the sidebar.

  • Choose the type of query you want to create (e.g., REST API).


Configure the Endpoint:

  • Enter the base URL and endpoint path for your API.

  • Select the HTTP method (GET, POST, PUT, DELETE) and add any necessary parameters, headers, or body content.


Test the Query:

  • Run the query to ensure it returns the expected data. Adjust configurations as needed.


Bind to Components:

  • Bind the query results to UI components to display data or trigger actions based on the query’s response.


Incorporating Different Components Like Containers, Tables, and Input Fields


Retool provides a wide range of components to build robust applications:


Containers:

  • Use containers to group related components and create structured layouts.

  • You can resize the containers, style them, and nest them to organize your app effectively.


Tables:

  • Add tables to display tabular data. Configure the data source to populate the table with query results.

  • Tables suppo2rt features like sorting, filtering, and pagination.


Input Fields:

  • Use input fields to capture user data. These include text inputs, dropdowns, checkboxes, and more.

  • Bind input fields to queries to dynamically update data based on user input.


Following these steps, you can design and build robust, interactive applications in Retool. For more detailed guidance, visit Retool’s guide on building business software and explore the comprehensive tutorials and guides.


Check out why the developers love Retool to use as a low-code tool and make an informed decision that leads to surprising results.


The following section will guide you through the detailed use of API data to populate application components in Retool.


Using API Data to Populate Application Components in Retool


Retool offers a robust platform for creating internal tools using data from different APIs. This flexibility empowers developers to build dynamic applications that fetch, display, and manipulate real-time data. Integrating external APIs can enhance Retool applications, making them more responsive and data-driven. This guide covers invoking API endpoints, populating tables with API data, and using features like filtering, pagination, and CRUD operations.


Process of Invoking API Endpoints to Retrieve Data


Invoking API endpoints in Retool involves creating queries that interact with your external APIs. Here’s a step-by-step process:


Create a New Query:

  • Navigate to your Retool app and click the "+" button to create a new query.

  • Select the type of API you want to connect to, such as REST or GraphQL.


Configure the API Request:

  • Enter the API endpoint URL and choose the HTTP method (GET, POST, PUT, DELETE).

  • Add any required headers, parameters, and body content using the API.


Test the Query:

  • Run the query to ensure it retrieves the expected data. Adjust the configuration if needed.


Save the Query:

  • Save the query and give it a descriptive name for easy identification.


Examples of Populating a Table with Data from an API


To populate a table with data from an API in Retool, follow these steps:


Create and Test the Query:

  • As described above, create a query to fetch data from your API.

  • Ensure the query returns the data in the expected format, typically an array of objects.


Add a Table Component:

  • Drag and drop a Table component onto your canvas from the component library.


Bind the Query to the Table:

  • In the Table component's properties panel, set the data source to the query you created.

  • For example, if your query is named getUsers, set the data property of the table to {{ getUsers.data }}.


Customize Table Columns:

  • Configure the table columns to display relevant fields from the API data. You can rename columns, format data, and add sorting or filtering as needed.


Using Filter, Pagination, and CRUD Operations with APIs


Filters and Pagination:

  • Filters: Add input components like dropdowns or text inputs to capture filter criteria from the user. Bind these inputs to your query parameters to dynamically filter the data.

  • Pagination: Implement pagination by configuring your query to accept pagination parameters (e.g., page and pageSize). Update the query results based on the user's interaction with pagination controls.


Example of Pagination Setup:


Add Pagination Controls:

  • Add buttons or a pagination component to navigate between pages.

  • Bind these controls to variables that represent the current page and page size.


Modify the Query:

  • Adjust the query to include pagination parameters:javascript


const page = {{ currentPage }};

const pageSize = {{ pageSize }};

return fetch(`/api/users?page=${page}&size=${pageSize}`)

  .then(response => response.json());


CRUD Operations:

  • Create: Use forms and input fields to capture new data entries. Submit the data to the API using a POST request.

  • Read: As described, fetch and display data in components like tables.

  • Update: Allow users to edit data in place or through a modal form. Send the updated data to the API using a PUT or PATCH request.

  • Delete: Add buttons or actions to delete records. When these actions are performed, trigger a DELETE request to the API.


Example of an Update Operation:


Create an Edit Form:

  • Add input fields and pre-fill them with the data you want to edit using the selected row in the table.

  • Bind the form inputs to a state variable representing the current item.


Submit the Update:

  • Add a button to submit the form. Configure the button to trigger a query that sends a PUT request with the updated data.


const updatedData = {

  id: {{ currentItem.id }},

  name: {{ currentItem.name }},

  email: {{ currentItem.email }},

};

return fetch(`/api/users/${updatedData.id}`, {

  method: 'PUT',

  headers: { 'Content-Type': 'application/json' },

  body: JSON.stringify(updatedData),

}).then(response => response.json());


Following these steps, you can effectively use API data to populate and interact with components in Retool, creating dynamic and responsive internal tools.


Now, move on to the next step, where you can customize and extend your application in Retool.


Customizing and Extending Your Application in Retool


Retool offers a wide range of customization options to enhance the functionality of your applications. You can integrate utility APIs, customize resource queries, and improve user interactions with pre-built and custom widgets. These options allow you to create dynamic applications that meet your specific needs.


Integrating Utility APIs for Added Functionalities


Integrating utility APIs into your Retool applications can significantly enhance their functionality. By leveraging APIs like ApyHub for utility services, you can add features such as data validation, document generation, and more. Here’s how to integrate an API:

  • Create a New Resource: Navigate to the Resources tab, select "Create new", and choose "REST API".

  • Configure the API: Enter the API's base URL and any necessary headers. For example, set the base URL to https://api.apyhub.com and include an authorization header if required.

  • Test the API: Create a query to test the API connection and ensure it returns the expected data.


Customizing Resource Queries for Specific Use Cases


Customizing resource queries allows you to tailor your application to specific needs. For instance, you can use SQL, JavaScript, or other query languages to interact with your data sources:

  • Create and Configure Queries: Open the query editor, select the resource, and write your custom query. For example, to fetch user data, you might use:

SELECT * FROM users WHERE status = 'active'


  • Dynamic Queries: Make your queries dynamic by using variables and inputs. For example, add a dropdown to filter users by role and bind this input to your query.


Enhancing User Interactions with Pre-Built and Custom Widgets


Retool provides a wide array of pre-built widgets like Tables, Charts, Forms, and Buttons, which you can use to enhance user interactions. Additionally, you can create custom components using HTML, CSS, and JavaScript:

  • Pre-Built Components: Drag and drop components from the library onto your canvas. For instance, a table component can display data, and a button component can trigger actions.

  • Custom Widgets: To build custom components, use the iFrame Code field in the Inspector to write your HTML, CSS, and JavaScript. For example, you can create a custom input field that updates a query dynamically:


<input type="text" onkeyup="updateQuery(event)" />

<script>

  function updateQuery(event) {

    window.Retool.modelUpdate({ searchTerm: event.target.value });

  }

</script>


Integrating utility APIs, customizing queries, and enhancing user interactions with pre-built and custom widgets can create highly functional and responsive Retool applications. For more detailed information, visit Retool’s official documentation on advanced app examples​ and custom components.


Now, move on to the next section of publishing and deploying your Retool application.


Publishing and Deploying Your Retool Application


To deploy your Retool application successfully, follow these critical steps: thoroughly test functionality, manage access and permissions for team members, and follow a structured deployment process for a smooth transition from development to production.


Test the Functionality of Your Retool Application


Before deploying your Retool application, it is essential to thoroughly test its functionality to ensure it operates correctly and meets user requirements. Here’s how to do it:

  • Run in Preview Mode: Use Retool's preview mode to simulate how the application will function in a production environment. Test all interactions and workflows to ensure everything works as expected.

  • Validate Data Queries: Verify that all queries execute properly, fetching and displaying the correct data. Check for any errors or performance issues in query execution.

  • Simulate User Actions: Perform a comprehensive test by simulating various user actions and inputs to identify potential bugs or UI/UX issues.


Steps to Publish and Deploy Your Application Within an Organization


Deploying your Retool application involves several steps to ensure it is accessible and secure for your team:


  1. Final Review: Double-check all configurations, including data bindings, API integrations, and user permissions.

  2. Publish the App:

  • Click on the “Publish” button in the Retool editor to make the app available to your team.

  1. Deploy to Production:

  • If you use self-hosted Retool, ensure your deployment environment (like Kubernetes or Docker) is configured correctly. Use tools like Helm to deploy Retool on Kubernetes.

  • Follow the detailed steps in the Retool deployment guide for specific instructions on setting up and managing your deployment environment.


Managing Access and Permissions for Team Members


Properly managing access and permissions is crucial to maintaining security and control over your Retool applications:


User Roles:

Assign roles to team members based on their responsibilities. Retool allows you to define roles with specific permissions, such as Admin, Developer, or Viewer.


Set Permissions:

Configure permissions for each role to control access to different parts of the application and its data. For instance, limit editing rights to developers and provide view-only access to end-users.


Audit and Monitor:

Review access logs and audit trails regularly to monitor user activities and ensure compliance with your organization’s security policies.


Refer to Retool's user management documentation for comprehensive details on managing users and permissions.


Following these steps ensures you thoroughly test Retool applications, securely deploy them, and adequately manage them within your organization. This structured approach helps maintain application integrity and provides a seamless experience for all users. For additional information, refer to the deployment guide.


You can also check out Retool’s pricing tiers and packages and decide to use Retool to achieve your goal.


The final part of this article will highlight all the important pointers for you to brush up on what you have learned so far!


Conclusion


Building internal software with Retool is a streamlined and efficient process that empowers teams to create robust applications quickly. Starting with setting up your Retool account, you can easily integrate various data sources and APIs, customize resource queries, and design user-friendly interfaces using pre-built and custom widgets. The process includes thorough testing to ensure functionality, followed by publishing and deploying the application within your organization while managing access and permissions to maintain security and control​.


Whether you're looking to automate workflows, build complex dashboards, or enhance user interactions, Retool offers the tools and flexibility to meet your needs. Start experimenting with different APIs, customize your queries, and leverage the powerful features Retool provides. Embrace the future of internal tool development and transform your business operations today. Visit Toolpioneers for additional help and get started!


Comments


bottom of page