As we conclude our Webinar Insights series, this final post features a step-by-step demonstration of Adaptigent’s Fabric Studio in action. Building on the challenges and capabilities explored in previous blogs, ranging from architectural complexity and system adaptability to inbound and outbound integration, this segment shows how Fabric Studio enables the creation of enterprise-ready APIs without writing code.
The demo walks through practical use cases, including:
- visual API design using COBOL copybooks
- terminal emulation for screen-based workflows
- orchestration with external services
Along the way, we highlight how these integrations are developed, tested, and deployed inside a configurable runtime environment.
Watch the full segment here
Visual API Construction Using Drag-and-Drop Logic
The session begins with a walkthrough of Fabric Studio’s Windows-based development environment. Users work on a central canvas known as the design workspace, where API flows are constructed visually. On the left, the toolbox provides access to a range of configurable nodes, each representing a discrete function, such as starting a flow, interacting with a host program, or calling an external service. When a node is selected, its properties can be configured in detail based on the service behavior required.
The demo highlights how easily the interface can be customized to match developer preferences. Elements such as the output log, explorer view, and ribbon layout can be repositioned or toggled as needed.
Two development options are demonstrated: creating an API manually from a blank canvas or using the Project Wizard. While the manual approach gives full control over each configuration, the wizard simplifies initial setup and is often preferred for its speed and consistency.
Example One: Creating an API from a Copybook
and Program
To demonstrate how Fabric Studio accelerates development, the presenter uses the wizard to build a new REST API called “getAccount.” This flow is based on a COBOL copybook and existing CICS transaction. The developer selects input and output fields directly from the copybook structure. In this case, the API is designed to accept a first and last name and return the associated account number.
Once the inputs are selected, Fabric Studio automatically assembles the flow, mapping inputs and outputs to their respective nodes. Static values can be added where needed, such as for error modes or conversation states. This is particularly useful when certain fields do not require user input and should not appear in the final API contract.
With just a few modifications, including setting user credentials and updating node properties, the API is deployed to a local runtime server. Using the integrated test tool, the presenter calls the API in a browser, passing “Mary” and “Smith” as the input values. The result is a successful response containing account number 10002, confirming that the API correctly retrieved the data from the CICS program.
An integrated emulator view allows users to verify the result directly on-screen, confirming that the returned data matches the host system’s response.
Example Two: Screen-Based Integration When Copybooks Are Not Available
The second example demonstrates a use case where copybooks are not accessible. Instead, the flow is built using an emulator recorder, which captures and replicates the sequence of screens a user would normally navigate through manually. The developer moves from the welcome screen to an application selection page, simulating the necessary inputs along the way.
The API retrieves address data for a given account number and then chains that data into a call to a third-party ZIP code statistics service. This external API returns demographic and regional information, which is appended to the response. For example, a ZIP code pulled from the mainframe is used to retrieve the MSA name “Orlando-Kissimmee-Sanford” from the external source.
This flow demonstrates how internal and external systems can be connected in real time through Fabric. Host screen navigation, business logic execution, and outbound API calls all happen within a single, unified service.
The project also includes annotations using floating comments. These help document the behavior of each section, which is useful for ongoing support or for other team members who may need to maintain the flow in the future.
Detailed Tracing for Debugging and Validation
One of the key strengths of Fabric Studio is its built-in tracing functionality. In this demo, the presenter enables full tracing to show how every step of the flow is logged. This includes input validation, node execution, screen transitions, and service responses.
The trace log reveals exactly how the API moves from screen to screen before executing the outbound request to the external ZIP code service. It also confirms the format and contents of the data exchanged at each point. While full tracing is generally reserved for development and QA environments, it plays a critical role in validating behavior and resolving errors before deployment.
Ingesting an External OpenAPI Document
To conclude, the demo shows how Fabric Studio can ingest an existing OpenAPI specification and convert it into a usable project. In this case, a ZIP code data service is imported, and Fabric automatically generates nodes for each operation defined in the OpenAPI document.
Inputs and outputs are pre-mapped, and error-handling logic is added based on HTTP response codes. While some fine-tuning is often needed for authentication or payload adjustments, this feature allows teams to rapidly incorporate third-party services into their integration architecture without starting from zero.
This ability to ingest and adapt OpenAPI documents is particularly valuable in hybrid integration environments, where systems must interface with a mix of internal, partner, and public APIs.
From Integration Challenges to Operational Execution
Adaptigent’s Fabric Studio gives IT teams a fast, low-code way to build APIs that connect host applications to modern platforms. Whether pulling data from a mainframe, simulating terminal navigation, or orchestrating external services, Fabric Studio provides the tools needed to design, test, and deploy production-ready APIs in a fraction of the time required by traditional development approaches.
This demonstration ties together the core themes explored throughout the Webinar Insights series—from managing complexity and enabling real-time access to simplifying integration and applying APIs in production environments. What began as a conversation around industry challenges now closes with a clear view of how those challenges are solved through practical, no-code development. The full workflow shown here is not just a showcase of features, but a representation of what modern integration can look like when strategy meets execution.
Learn more about Adaptive Integration Fabric