A Lookup Cache is a powerful tool for centrally storing and retrieving frequently used reference data. In another article, we demonstrate how to use the Lookup Cache for large datasets. It is especially useful for managing dynamic, environment-specific variables that change over time, such as inventory thresholds, pricing rules, or region-specific settings.

Here, we’ll explore how Lookup Cache can be used to manage environment-specific variables through APIs.

Lookup Cache demo

Lookup Cache overview

Why use Lookup Caches in your flows?

• Faster data lookups: Reduces dependencies on external systems, improving flow efficiency.
• Scalable mappings: Handles large datasets better than static or dynamic lookups.
• Reusable and flexible: Acts as a lookup table, environment-specific variable store, or centralized reference data repository.
• Easier maintenance: Data can be loaded via CSV files or updated dynamically using Integrator.io APIs.

The business problem

Imagine you need to monitor inventory levels in Shopify and send Slack notifications when stock for certain SKUs falls below a predefined threshold. These thresholds vary based on SKU, seasonality, and demand at specific locations, making it impractical to use static data.

You could manually maintain thresholds by uploading CSV files or using external systems, but that approach is time-consuming and challenging to scale. Instead, we’ll use Lookup Cache as a centralized, dynamic repository for these thresholds, enabling automated updates and seamless data retrieval across flows.

Lookup Cache use case

Automating Slack notifications for low stock

In this example, we’ll:

• Automatically populate and update a Lookup Cache with SKU inventory thresholds using the Integrator.io API.
• Retrieve threshold values dynamically from the Lookup Cache and trigger Slack notifications for SKUs with low stock.

Step 1: Populate the Lookup Cache with thresholds

To manage thresholds dynamically, I’ve set up a flow that:

• Exports inventory data, including SKUs, stock levels, and item IDs, from Shopify.
• Uses the Integrator.io API to populate a Lookup Cache with this data.

Here’s how the Lookup Cache is structured:

• Key: Inventory Item ID (unique identifier for each item).
• Value: A JSON object containing the SKU, location, and threshold.

Steps in detail

1. Export inventory data: Create a flow to fetch inventory details from Shopify, including SKUs and stock levels.
2. Import to Lookup Cache: Add an import step to the flow that uses the Integrator.io API to update the Lookup Cache. The API supports bulk updates in a key-value array format.
3. Default thresholds: Use the Mapper to set a default threshold value during import. These thresholds can later be adjusted directly in the Lookup Cache UI or via CSV for bulk updates.

Once the flow runs, the Lookup Cache is automatically populated with SKU-specific thresholds, creating a centralized and consistent repository.

Step 2: Trigger notifications for low stock

Now that the Lookup Cache is populated, let’s create a main flow to monitor stock levels and send Slack notifications when stock is low.

Steps in detail

1. Fetch inventory levels: Set up an export step to fetch current inventory levels from Shopify.
2. Retrieve threshold values: Use the Lookup Cache API to dynamically retrieve the threshold for each SKU based on its Inventory Item ID.
   • Send the Inventory Item ID as the key in the API request.
   • Retrieve the associated value from the Lookup Cache, which includes the SKU, location, and threshold.
3. Validate stock levels: Add an input filter to check if the current stock is below the threshold or empty. Only records meeting these conditions proceed to the next step.
4. Send Slack notifications: For SKUs with low stock, trigger a Slack notification alerting your team.

Why use Lookup Cache for environment-specific variables?

With Lookup Cache, managing environment-specific variables like inventory thresholds becomes seamless. You can automate updates, dynamically retrieve data, and maintain consistency across flows—all without the need for manual intervention.

• Centralized management: Store thresholds in one place, making updates simple and consistent across workflows.
• Dynamic updates: Automatically populate and update thresholds using flows or APIs, eliminating manual maintenance.
• Flexibility: Retrieve and consume data in real time through APIs, enabling responsive workflows.
• Scalability: Handle complex variables like SKU-specific thresholds, pricing rules, or regional settings easily.

Lookup Cache is a powerful tool for dynamically managing environment-specific variables, ensuring that workflows remain accurate, automated, and scalable.

By leveraging the Integrator.io API, you can centralize critical data like inventory thresholds, reduce manual updates, and enable real-time decision-making across your integrations.

Whether you’re handling inventory management, pricing rules, or region-specific settings, Lookup Cache provides the flexibility, efficiency, and reliability needed to streamline operations.

→ Learn more about the Lookup Cache.