Build scalable middleware applications with Catalyst

Build powerful middleware solutions

With its focus on seamless integration and scalability, Catalyst empowers developers to manage APIs efficiently, integrate data, and build resilient, scalable solutions for modern enterprise needs.

• API gateways

  Securely manage, scale, and optimize your API traffic for maximum performance and availability.

• Data integration

  Effortlessly connect and synchronize data across systems for seamless workflows and better decision-making.

• Microservices middleware

  Develop resilient, cloud-native middleware for modern applications based on a microservices architecture.

• Message queuing

  Enable high-performance communication between your application components with Catalyst’s message queuing features.

Key Catalyst components for middleware development

Functions

• Purpose: Use serverless computing to execute backend logic

• Use case: Build event-driven workflows, automate processes, or integrate APIs without managing infrastructure.

Types of Catalyst functions

• Basic I/O functions: Basic I/O functions: Simple input and output operations

• Advanced I/O functions: API functions that support HTTP headers and requests

• Event functions: Triggered automatically by Catalyst events

• Cron functions: Run at scheduled intervals

• Integration functions:Integration functions: Connect Catalyst with Zoho services

• Browser logic functions: Manages and automates browser tasks effortlessly

Code sample: Create a simple user greeting function in Catalyst

This code demonstrates how to create a simple Catalyst function that greets users by name, using a basic I/O function for handling input parameters and output responses.

        class OrderService:
            def __init__(self, db):
                self.db = db
        
            def place_order(self, user_id, product_id):
                user = self.db.get_user(user_id)
                product = self.db.get_product(product_id)
                if user and product:
                    self.db.create_order(user_id, product_id)
                    return "Order placed successfully!"
                return "Order failed."
        
        # Everything interacts within the same system
        class Database:
            def get_user(self, user_id):
              # Query database for user
              pass
        
            def get_product(self, product_id):
              # Query database for product
              pass
        
            def create_order(self, user_id, product_id):
              # Insert order into database
              pass
                       

Data Store

• Purpose: Manage data efficiently with a cloud-based relational database.

• Use case: Reliably store scalable user data, transactional logs, and session states.

• Best practice: Use data indexing for fast querying and efficient retrieval.

Code sample: Inserting records in Data Store

Data Store is useful for a supply chain or retail application that manages orders and inventory. We'll create two tables:

• An orders table to store customer orders

• An inventory table to store product stock information

This sample code is for placing an order and updating inventory by inserting a new order record into the orders table and reducing the stock quantity in the inventory table.

class OrderService:
    def __init__(self, db):
        self.db = db

    def place_order(self, user_id, product_id):
        user = self.db.get_user(user_id)
        product = self.db.get_product(product_id)
        if user and product:
            self.db.create_order(user_id, product_id)
            return "Order placed successfully!"
        return "Order failed."

# Everything interacts within the same system
class Database:
    def get_user(self, user_id):
      # Query database for user
      pass

    def get_product(self, product_id):
      # Query database for product
      pass

    def create_order(self, user_id, product_id):
      # Insert order into database
      pass
               

Push notifications

• Purpose: Engage users with real-time, scalable notifications.

• Use case: Send critical alerts or updates from middleware systems to users across devices.

Push notifications can alert users about important updates, offers, or real-time information, enhancing engagement. Here's how you can enable notifications in Catalyst

Code sample: Enable push notifications

This code enables push notifications and displays an alert or redirects to a sales page, based on the notification title.

class OrderService:
    def __init__(self, db):
        self.db = db

    def place_order(self, user_id, product_id):
        user = self.db.get_user(user_id)
        product = self.db.get_product(product_id)
        if user and product:
            self.db.create_order(user_id, product_id)
            return "Order placed successfully!"
        return "Order failed."

# Everything interacts within the same system
class Database:
    def get_user(self, user_id):
      # Query database for user
      pass

    def get_product(self, product_id):
      # Query database for product
      pass

    def create_order(self, user_id, product_id):
      # Insert order into database
      pass
               

API gateway

• Purpose: Manage and route client requests to microservices or other components, offering enhanced security and scalability.

• Use case: Decouple client applications from backend services; provide routing, authentication, and throttling; and ensure better control over API interactions.

Catalyst's API gateway reduces development time by centralizing features, allowing developers to focus on core functionality.

User authentication

• Purpose: Manage user accounts, secure access, and customize your application's login experience.

• Use case: Enable user registration, social logins, and role-based access control for secure and personalized user experiences.

Authentication in Catalyst allows you to manage end users, customize sign-in forms, create roles for user permissions, and integrate social logins like Google or Zoho. This simplifies user management while ensuring secure access to your application.

Why build middleware with Catalyst?

• Scalable architecture

  Handle high volumes of data and traffic effortlessly. Catalyst’s cloud-native infrastructure ensures your middleware can scale with your business needs, allowing for smooth and uninterrupted performance.

• Seamless integration

  Integrate effortlessly with APIs, databases, cloud platforms, and third-party services. Catalyst’s tools provide you with prebuilt connectors and custom integration options to ensure seamless communication across systems.

• Faster development, lower costs

  Reduce development time with Catalyst’s user-friendly features and minimal learning curve. Focus on innovation, not infrastructure. Spend less time coding and more time solving real business problems.

• Built-in security and compliance

  Ensure enterprise-grade security with Catalyst’s built-in features like data encryption, identity management, and more. Stay compliant with industry standards while developing mission-critical middleware solutions.

Examples and architecture diagrams

Streamlining supply chain operations for a manufacturing firm:

A manufacturing company wants to optimize its supply chain operations, enhance inventory management, and automate procurement processes to ensure timely deliveries and reduce operational costs. However, the company faces challenges with inefficient inventory tracking, manual procurement workflows, and poor supplier communication, resulting in stock outs, delays, and operational bottlenecks.

How Catalyst can address these challenges

Catalyst serves as a middleware layer, seamlessly integrating the company’s existing supply chain systems.

• Real-time inventory management with Data Store:

  Catalyst's Data Store serves as a centralized data layer, syncing inventory levels across multiple warehouses and ERP systems, ensuring accurate stock tracking, and preventing discrepancies

• Seamless supplier communication with API gateways:

  Catalyst's API gateway facilitates secure and standardized API interactions between the company’s suppliers and logistics partners, automating order placement, tracking, and supplier coordination. It efficiently handles API calls by managing routing, authentication, and throttling, ensuring reliable and controlled access to backend services.

• Predictive inventory optimization with QuickML:

  QuickML processes historical sales and stock movement data to forecast demand, helping businesses automate restocking decisions and prevent stock outs or overstock situations.

Architecture diagram

Here’s an architecture diagram showing how Catalyst components work together to optimize the supply chain process.

Enhancing customer experience and personalization for online service platforms

Online service platforms like education, health and wellness, financial advisory, and home services struggle to tailor user experiences, retain clients, and automate service delivery. Many firms encounter difficulties such as low user engagement, inefficient appointment scheduling, and a lack of AI-powered recommendations, which result in missed income opportunities and high customer churn.

How Catalyst can address these challenges

• AI-powered personalized recommendations: Catalyst QuickML uses user behavior, preferences, and previous interactions to offer services, increasing conversions and retention.
• Automated appointment scheduling: Catalyst's functions automate appointment scheduling, service booking, and reminders, minimizing manual coordination and providing a more seamless experience.
• Automated subscription and billing management: Catalyst's API gateway streamlines API management for basic I/O, advanced I/O, and web client hosting, helping organizations integrate payment gateways and subscription platforms.
• Real-time user engagement: Catalyst's push notifications and email automation ensure that users receive timely information, service reminders, and personalized offers, keeping them engaged.
• Catalyst Data Store: A cloud-based relational database for storing and managing your app’s backend and user data. It supports ZCQL queries, role-based permissions, and integrates seamlessly with Catalyst SDKs and APIs.