From Months to Minutes: Scaling SaaS Integrations with a Config-Driven Gateway

Building and maintaining integrations is a critical pillar for any modern SaaS platform, especially one like Appsmith that powers thousands of internal tools, dashboards, and workflows across industries.

But as our user base grew and integration demands exploded, we faced a classic scale challenge: How do you ship and maintain dozens of high-quality, secure integrations without turning our engineering roadmap into a never-ending backlog?

Here's our journey from a code-heavy, slow integration cycle to a config-driven, scalable, and secure architecture. This post details the technical strategies, architectural patterns, and vendor evaluation frameworks that enabled us to reduce our integration delivery timeline from 3–6 months to just one day.

If you're a technical leader or architect evaluating external integration vendors, or designing your own integration architecture, this post is for you.

Appsmith began as a developer-focused low-code application platform in 2019. As our product matured in coming years, our integration needs shifted from a handful of database connectors to a sprawling catalog of SaaS tools — CRMs, ticketing systems, messaging apps, AI services, and more. Each new integration meant weeks (often months) of:

• Deep-diving into third-party API documentation and authentication flows

• Custom authentication and data mapping logic development

• Full SDLC: development, QA, deployment, and ongoing support

• Security reviews and compliance validation for each integration

Here's a snapshot of the integrations currently available in Appsmith — spanning SaaS platforms, AI services, and more. It shows just how many different tools our users can connect to their internal applications in a few clicks:

While our original approach worked well when our product was green, it was unsustainable. Requests for new integrations grew exponentially. We needed to overhaul our process to accelerate delivery, reduce maintenance overhead, maintain security, and support rapid enterprise onboarding.

We considered a range of other options before settling on our final approach of building a config-driven integration architecture.

Before turning to external solutions, we first needed to examine whether we could solve our integration bottleneck by simply optimizing our internal workflows or scaling up our engineering team. However, even with more resources, each new integration still required deep dives into third-party docs, custom authentication logic, and ongoing support — making the process brutally slow and difficult to scale.

We also considered building a fully custom, in-house integration platform. While this would offer complete control, it would have meant significant upfront investment, continuous maintenance, and the need to keep pace with evolving third-party APIs and security requirements — ultimately distracting us from our core product roadmap.

While REST APIs and GraphQL provide basic connectivity, our users need much more: seamless authentication, multi-account support, dynamic UI elements, and native integration experiences. Relying on simple REST connectors would force users to handle complex OAuth flows and manual data mapping, resulting in a fragmented and less secure experience.

The real breakthrough came when we decided to shift from code-heavy, one-off integrations to a config-driven model powered by an integration gateway. This switch allows us to deliver integrations as simple configurations — removing the need for custom code with each new service, and letting us focus our engineering energy on architecting a scalable, secure, and resilient integration infrastructure.

By using an integration gateway as a foundational component, we could abstract away authentication complexity and standardize integration patterns.

Once our engineering team decided to pursue an integration gateway approach, we commenced a rigorous evaluation of vendors, screening to find one that enabled rapid delivery, granular rollout, and enterprise-grade security at scale. 

Ultimately, we chose Paragon. Read their case study about the experience here.

Choosing an integration partner proved to be the easy part, however. The real magic that enabled us to dramatically improve our time-to-delivery for new integrations came through the particular way we architected our solution for scale, security, and maintainability.

To support rapid integration delivery at scale, we reimagined our architecture around two core ideas: config-driven deployment and a secure proxy-based execution model. This section breaks down how those principles shaped the foundation of our new integration infrastructure.

Core Design Principles for a Scalable Integration Platform

Like all companies, Appsmith has distinct needs that influence how we architect our infrastructure. For our integration process, these considerations were top-of-mind:

• Self-hosted Gateway: The vast majority of Appsmith customers choose to self-host our platform. As a result, we needed an integration gateway that can run inside your infrastructure — without any external dependencies for enterprise customers.

• Config-Driven Deployment: Integrations are foundationally important to low-code platforms, so we needed the ability to spin up new ones easily — via configuration, not code changes.

• Proxy Pattern: Because integrations form the backbone of our platform, we needed to ensure security, observability, and control as much as possible. We needed an integration gateway that could route all traffic through our own Appsmith Cloud Services as a secure proxy.

• Zero-Deployment Updates: We needed these integrations to be flexible, so we could roll them out to all customers without forcing an upgrade to the platform.

• Feature Flags and Rollout Control: To support safe and targeted deployment, our architecture includes granular feature flags and rollout controls. This allows us to enable integrations by business tier, customer, or environment (e.g., staging to production), rapidly roll back changes if needed, and run A/B tests for new integration experiences — all without user disruption.

• Fallback and Resilience: Reliability is critical, so we built in robust fallback mechanisms. All integration configs and schemas are cached locally with TTL-based refresh, ensuring continued operation even if the integration gateway is temporarily unavailable. Circuit breaker patterns prevent cascading failures, and our design allows for seamless migration between vendors without customer downtime.

This diagram shows how Appsmith built out this config-driven, proxy-based approach to manage integrations at scale. As you can see, all integration requests flow through Appsmith Cloud Services, which acts as a secure proxy to the integration gateway (Paragon). Periodically, new integrations synchronize to the local Appsmith database, which makes them available to the Appsmith server.

This setup enables centralized management, enhanced security, and rapid deployment of new integrations without code changes or user upgrades.

The architecture of Appsmith integrations is designed for maximum security, scalability, and ease of management by routing all integration traffic through Appsmith Cloud Services — a central system that acts as the backbone for plugin discovery, synchronization, authentication, and query execution.

• The integration gateway exposes a catalog of available integrations via a REST API.

• Appsmith Cloud Services runs scheduled cron jobs every six hours to fetch and synchronize this catalog, acting as the first cache layer.

• Each integration plugin comes with metadata detailing supported actions, authentication methods, and configuration schemas.

• These plugins are categorized (API, DB, REMOTE, EXTERNAL) and dynamically surfaced in the Appsmith UI.

• For self-hosted deployments, the Appsmith server (running within the customer's infrastructure) also schedules regular cron jobs to pull the latest plugin catalog from Appsmith Cloud Services. This establishes a two-tier caching system: Cloud Services as the first cache, and self-hosted server as the second cache, ensuring resilience and up-to-date access even in the event of network disruptions or vendor outages.

When a user wants to connect a new integration, the self-hosted Appsmith client initiates the process using the integration gateway SDK, which opens an OAuth modal. The authentication flow is as follows:

• Step 1: The self-hosted Appsmith server requests workspace-specific token from Cloud Services.  

• Step 2: Cloud Services generates a unique token using RSA keys and project metadata.  

• Step 3: The client initiates OAuth flow via integration SDK with workspace isolation.  

• Step 4: Upon successful authentication, a new data source is created in the self-hosted backend, storing the integration and credential metadata.

The Unified Query Interface (UQI) is a JSON-based configuration that tells Appsmith how to build the input forms users see when connecting to an integration. For each integration, the UQI defines what fields — like text boxes, dropdowns, or toggles — are needed to collect the right data from the user. This makes it easy to create custom forms for different APIs without writing extra code.

• The UQI configurations for all integrations are generated and cached centrally in the Appsmith Cloud Services database.

• When the Appsmith server (self-hosted instance) runs its scheduled cron jobs to sync plugins from Cloud Services, it also fetches and caches the corresponding UQI definitions.

• As a result, when a user creates a new data source via the self-hosted client, the Appsmith server can instantly present the relevant, pre-cached UQI-driven form — ensuring a seamless, responsive experience for building queries and interacting with connected integrations.

Whenever a query is executed against an integration, the request flows from the self-hosted Appsmith instance to Appsmith Cloud Services, which securely proxies the request to the integration gateway. The gateway then interacts with the target integration platform and returns the data, which is routed back through Cloud Services to the self-hosted server.

This approach ensures:

Security Benefits:

• No direct external IP whitelisting required

• Centralized security policy enforcement

• Request/response logging for audit

• Rate limiting and DDoS protection

Operational Benefits:

• Centralized monitoring and alerting

• Error aggregation and troubleshooting

• Performance metrics collection

• Circuit breaker patterns

Appsmith's integration infrastructure leverages granular feature flags and rollout controls to ensure safe, flexible, and targeted deployment of integrations:

• Tier-Based Enablement: Integrations can be enabled or restricted based on customer business tiers (e.g., Salesforce for Business+, Slack for Enterprise).

• Customer-Specific Controls: Admins can enable or disable integrations for specific customers as needed.

• Environment-Based Rollouts: Integrations can be rolled out progressively, starting with staging environments before moving to production.

• Rapid Rollback: Issue detection triggers instant rollback capabilities, minimizing user impact.

• A/B Testing: New integration experiences can be tested with subsets of users to optimize the rollout and gather feedback.

This system enables zero-downtime releases, supports experimentation, and ensures that new integrations can be introduced or updated with minimal risk.

To ensure enterprise-grade security and high availability, Appsmith's integration architecture leverages a self-hosted gateway at Appsmith Cloud Services as the central system. This design allows us to centrally manage authentication, enforce security policies, and maintain consistent uptime across all integrations.

• Local Caching with TTL-Based Refresh: Integration configurations and UQI schemas are cached both in Appsmith Cloud Services and on the self-hosted server, with time-to-live (TTL) based refresh. This two-layer caching ensures that, even if there are temporary connectivity issues, users retain access to existing integrations and configurations.

• Enterprise Security and Uptime: By routing all integration traffic through the self-hosted gateway at Appsmith Cloud Services, we provide a controlled and secure environment for managing authentication and data flows. This centralization not only enhances security but also improves resilience and reliability for enterprise customers.

• Vendor Independence and Migration: The architecture is designed to support seamless migration between integration vendors with minimal disruption, enabling updates and transitions without downtime.

• Circuit Breaker Patterns: Circuit breaker mechanisms detect repeated errors or timeouts from external services, temporarily suspending requests to protect overall platform stability.

This approach ensures that Appsmith delivers secure, reliable, and highly available integrations, meeting the needs of enterprise environments while minimizing the risk of outages or security breaches.

This new integration process has completely transformed the process of spinning up new data source integrations in Appsmith. 

Moving to a config-driven integration gateway approach has greatly sped up our integration capabilities, transforming the way Appsmith delivers value internally and to our users. Before this shift, launching a new integration typically took three to six months, but now we consistently get integrations up and running within a single day. This faster turnaround means we can quickly respond to user requests and industry changes. We've also cut the engineering effort needed for each integration by around 60–70%, letting our teams focus more on building out core features rather than getting bogged down in repetitive tasks.

In just six months after adopting this new system, we've rolled out over 15 integrations, demonstrating our improved ability to rapidly meet customer needs. By using feature flags and controlled rollouts, we've achieved zero-downtime releases, ensuring that users experience seamless transitions without disruptions.

Aside from speed, the new integration gateway brings significant qualitative benefits. Enterprise-grade security is built-in since all data flows through trusted infrastructure, eliminating complicated setups like external IP whitelisting. This simplifies onboarding and provides peace of mind for enterprise customers. Developers enjoy a better workflow, spending their time on meaningful logic and configuration instead of tedious boilerplate code. Customers benefit from instant access to new integrations, allowing them to quickly onboard and start getting value from Appsmith. Finally, our increased agility means we can experiment, refine, and adapt quickly — greatly reducing risk and continually improving our offerings.

The architecture transformation enabled us to:

• Respond to enterprise RFPs three times faster

• Reduce customer onboarding time by 80%

• Free up 2.5 FTE engineers to focus on core product innovation rather than integration maintenance

Our journey is ongoing. As we continue to scale, we're investing in:

• AI-driven integration builders for even faster onboarding of new APIs and legacy systems.

• Deeper monitoring and analytics for usage patterns and performance optimization.

• Community-driven integration catalog expansion via open-source contributions.

• Real-time data synchronization capabilities for event-driven architectures.

Based on our journey, here are core recommendations for any engineering team building scalable integration infrastructure:

Building a modular and extensible architecture ensures your platform can grow and adapt:

• Independent Lifecycle: Use a plugin-based approach so each integration can be managed, updated, or retired independently.

• Separation of Concerns: Keep your integration logic (code) separate from configuration (data) for easier updates and maintenance.

• Standardized Interfaces: Implement consistent interfaces for authentication, querying, and data transformation, making integrations easier to develop and manage.

• Schema Versioning: Version your integration schemas and support backward compatibility so users don't get locked out as the platform evolves.

Centralizing security and compliance simplifies management and strengthens your defenses:

• Simplified Management: Route all external traffic through a secure proxy, creating a single point for managing and monitoring security policies.

• Enhanced Security: Store sensitive credentials in a centralized, auditable service (like HashiCorp Vault) to protect secrets and enable thorough auditing.

• Consistent Enforcement: Apply rate limits, logging, and monitoring at the proxy to ensure all integrations meet your security and compliance standards.

• Zero-Trust Networking: Authenticate and authorize every request, no matter its origin, to minimize breach risks.

Automating the integration lifecycle streamlines operations and reduces manual effort:

• Automated Sync: Use scheduled jobs to keep integration catalogs and schemas up to date.

• Dynamic UI Generation: Automatically generate user interfaces for new APIs, removing the need for manual UI work.

• Automated Testing: Create integration-specific test suites to catch issues early.

• Continuous Health Monitoring: Monitor integrations continuously to detect problems before they escalate.

Feature flags provide granular control over how and when integrations are released:

• Granular Availability: Enable or restrict integrations by customer tier, region, or other criteria.

• Phased Rollouts: Launch integrations in stages (e.g., from staging to production) to minimize risk.

• Instant Enable/Disable: Quickly turn integrations on or off for specific customers as needed.

• A/B Testing and Rollback: Test new features with subsets of users and automate rollbacks if issues arise.

Vendor independence ensures your platform remains flexible and resilient:

• Minimize Coupling: Favor standard protocols and avoid deep reliance on vendor-specific features.

• Local Caching: Store configs and schemas locally so integrations keep working during vendor outages.

• Abstraction Layers: Decouple your core logic from vendor implementations to simplify vendor swaps and API updates.

• Migration Documentation: Maintain clear steps for migrating integrations, including data transfer and authentication updates.

• Fallback Strategies: Design with backup options in case vendors change or become unavailable.

Continuous improvement keeps integrations reliable and performant:

• Early Issue Detection: Use automated tests and real-time monitoring to catch issues before they affect users.

• Reliability Tracking: Monitor error rates and latency to proactively address problems.

• Rapid Response: Set up alerts for quick action on failures, reducing downtime.

• Performance Optimization: Analyze usage patterns regularly to refine integrations for speed and efficiency.

Investing in these best practices leads to a more stable, secure, and adaptable integration platform that can scale with your business and user needs.

Building a great integration platform requires careful balance between technical architecture, vendor partnerships, and business strategy. For us, the most successful approach combines the right mix of build vs. buy decisions, config-driven architectures, and vendor-independent designs.

Ready to experience these integrations for yourself? They're available now in Appsmith Business and Enterprise versions v1.77 and above. Try them out now, and reach out to the Appsmith engineering team on Discord to learn more or contribute to our integration architecture yourself!