Learning Appian Records Using Integrations

Now that we’ve successfully set up our Database instance locally and exposed it to the internet using a tunneling service, it’s time to test the connection from Appian.

In this session, we will:

• Verify that Appian can reach your local DB instance through the tunnel URL.

• Create a Connected System in Appian using the public endpoint.

• Build a basic Integration object to fetch data from the DB.

• Test the Integration using sample data to confirm that the connection is working as expected.

This step is crucial to ensure that your setup is ready for building Appian Records powered by external data.

By the end of this session, you’ll be able to:

• Confirm successful connectivity between Appian and your local database.

• Troubleshoot common connection issues.

• Prepare for building dynamic Records using real-time data from the DB.

Let’s move ahead and validate our integration setup!

In this chapter, we’ll dive into the fundamentals of setting up a new database and performing essential operations to get it up and running. You will learn how to establish a reliable connection between your application and the database, followed by step-by-step instructions to create a new database from scratch.

We’ll also cover how to insert initial records into your database—one of the most crucial tasks in any application development. From simple value insertion to handling bulk data inputs, this chapter will guide you through it all.

Additionally, we'll introduce you to various CRUD operations (Create, Read, Update, Delete) that can be performed on the selected database. Each concept will be explained in a practical, beginner-friendly manner, allowing you to follow along whether you're using SQL directly or working within a low-code environment.

By the end of this session, you'll be equipped with the foundational skills needed to manage and manipulate databases effectively.

In this chapter, we take a big step forward by learning how to send large sets of data from Appian to external systems like DB using REST APIs. This introduces a more advanced level of communication between Appian and third-party services—enabling real-time data exchange and automation.

What You Will Learn in This Chapter:

1. Understanding the Need for Bulk Upload

• Why bulk data operations are useful in real-world apps.

• When to use _bulk_docs and what it supports.

2. Establishing Real-Time Communication

• How to expose CouchDB through a public tunnel (using ngrok or similar tools).

• Configuring Appian to securely send data to an external API.

• Setting up headers, endpoints, and HTTP methods properly.

3. Structuring Bulk Data Payloads

• Understanding the required JSON format for CouchDB’s _bulk_docs API.

• Using a!forEach() and a!toJson() to dynamically create an array of documents.

• Avoiding common mistakes like missing _id fields or incorrect nesting.

4. Sending Data from Appian

• Building the Integration object in Appian for POST requests.

• Binding dynamic payloads to real use-case data (orders, records, logs, etc.).

• Executing the Integration and observing the response.

5. Receiving and Validating Responses

• How DB responds to bulk insert operations.

• Handling success and error responses in Appian.

• Logging inserted documents for verification.

6. Crafting the “Looping Recipe”

• Repeating the bulk insertion process dynamically with a!forEach().

• Generating unique data per iteration (like IDs, names, timestamps).

• Building reusable logic for other APIs with similar structures.

✅ Outcome:

By the end of this chapter, you will have:

• Built a working integration from Appian to DB (or any REST-compliant system).

• Sent multiple documents in one go using JSON.

• Created a dynamic looping structure to automate and scale API calls.

• Validated a complete real-time communication cycle between Appian and an external system.

Chapter Description:

In this session, we’ll complete our full data flow cycle by performing a GET call from Appian to DB to retrieve and view the inserted documents.

Now that we’ve successfully inserted multiple records into DB, it’s time to test whether Appian can fetch and display them in real time. This is where everything we’ve built—tunneling, data insertion, and integrations—comes together.

? What You Will Learn:

• How to configure a GET Integration in Appian to connect with DB.

• Setting the correct endpoint (e.g., /_all_docs?include_docs=true) to return all documents with their details.

• Using headers and query parameters if required.

• How to parse the response JSON and extract the actual data from the rows array.

• Displaying the retrieved documents in a readable Appian interface, like a grid or a record list.

• Tips to filter, sort, or search fetched records dynamically.

? Outcome:

By the end of this session, you will have:

• Successfully retrieved data from an external system into Appian using a GET API.

• Understood how to format and use DB response.

• Created a complete round-trip integration: Insert → Store → Retrieve → View.