Why is middleware a game changer for modern apps?

Set up authentication in Catalyst

Enabling an authentication service

To set up authentication, you can enable the built-in authentication service in Catalyst.

1. Enable authentication and configure user signup and login.

2. Use OAuth-based authentication to manage user identities without writing custom authentication code.

Catalyst will handle user sessions, security, and tokens automatically.

Why this works:

• It eliminates the need to build custom authentication APIs.

• It ensures security and seamless user management

Monitor and analyze user activity in Data Store

• Log user engagement: Track login frequency and usage patterns to understand user behavior.

• Create a Data Store table: Set up a table to store activity data with fields like userId (string) and lastLogin (timestamp).

• Create a Catalyst function: Write a serverless function to log user logins and store data in Data Store.

Sample code to insert and add rows in Data Store:

    // API endpoint to upload quiz results to Catalyst DataStore
    app.post("/upload", async (req, res) => {
        try {
        // Initialize Catalyst for this request (renamed to avoid variable conflicts)
        const catalystApp = catalyst.initialize(req);
    
        // Access the Catalyst DataStore service
        const datastore = catalystApp.datastore();
    
        // Reference the 'quest' table in DataStore
        const table = datastore.table("your-table-name"); // Replace with your table name if different
    
        // Extract fields sent by the client
        const { username, score, stream, timeSeconds, gaveUp } = req.body;
    
        // Basic validation to ensure required fields are present
        if (!username || score == null) {
            return res.status(400).json({
            status: "failure",
            message: "Missing required fields",
            });
        }
    
        // Construct the row to be inserted
        const row = { username, score, stream, timeSeconds, gaveUp };
    
        // Insert the row into Catalyst DataStore
        await table.insertRow(row);
    
        // Send success response back to client
        return res.status(200).json({
            status: "success",
            inserted: row,
        });
    
        } catch (err) {
        // Log and return error response if insertion fails
        console.error("Insert error:", err);
        return res.status(500).json({
            status: "error",
            message: "Insert failed",
            error: err.message,
        });
        }
});
            

Predict user churn with QuickML

• Build predictive models: QuickML helps you build models to predict user churn, identifying users at risk of leaving based on their activity data.

• Seamless data integration with QuickML: Catalyst's Integration Functions can be highly useful for integrating Data Store with QuickML to fetch user activity data—such as login frequency and support interactions—and feed it directly into QuickML for real-time churn prediction. This ensures that models are trained with the latest insights without manual intervention.

• No-code pipeline: QuickML provides a drag-and-drop pipeline builder that doesn’t require coding, allowing you to configure data preprocessing steps easily.

Data preprocessing:

• Build predictive models:

Apply encoders (e.g., Ordinal or One-Hot Encoder) to convert categorical data (like "gender" or "geography") into numerical values.

Normalize numerical data using techniques like min-max normalization to improve model accuracy.

• Model readiness: The platform ensures your dataset is clean, consistent, and ready for model training, enabling fast, effective churn predictions.

ML endpoints: Powering real-time predictions

These endpoints, powered by trained ML models, enable continuous inference for real-time decision-making.

Once a model is trained in QuickML, users can deploy it and get an endpoint with the latest version. This endpoint can then process new data and deliver instant predictions. QuickML also monitors deployed endpoints, providing insights to refine and enhance model performance over time.

Harness the power of ML endpoints to keep your predictions accurate, scalable, and always improving.

Why this works:

• QuickML provides an easy-to-use, no-code platform to build machine learning pipelines.

• It enables developers to create AI models without needing expertise in data science or ML.

Sample code utilizing a model endpoint:

import java.net.*;
import java.io.*;
import org.json.JSONObject;

public class UserAnalytics {

public static double predictChurn(String userId, int loginFrequency, int supportTickets) {
try {
// Set up the model endpoint URL (replace with your actual endpoint)
String endpoint = "your_model_endpoint";

// Prepare the input data as a JSON object
JSONObject inputData = new JSONObject();
inputData.put("login_frequency", loginFrequency);
inputData.put("support_tickets", supportTickets);

// Create a connection to the endpoint
URL url = new URL(endpoint);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/json");
connection.setDoOutput(true);

// Send the data to the server
try (OutputStream os = connection.getOutputStream()) {
byte[] input = inputData.toString().getBytes("utf-8");
os.write(input, 0, input.length);
}

// Read the response from the server
try (BufferedReader br = new BufferedReader(
    new InputStreamReader(connection.getInputStream(), "utf-8"))) {
StringBuilder response = new StringBuilder();
String responseLine;

while ((responseLine = br.readLine()) != null) {
    response.append(responseLine.trim());
}

// Assuming the response contains the prediction result
JSONObject jsonResponse = new JSONObject(response.toString());
return jsonResponse.getDouble("prediction");
}

} catch (Exception e) {
System.err.println("Error during prediction: " + e.getMessage());
return -1.0; 
}
}
}

Send push notifications for user engagement

Enabling web push notifications in Catalyst

Catalyst allows you to integrate web push notifications into your app easily. Once enabled, you’ll get a code snippet to add to your web app for seamless notifications.

• Real-time engagement: Push notifications help keep users engaged by sending updates, reminders, or important events even when they’re not actively using the app.

• Easy integration: Catalyst provides a simple code snippet that integrates push notifications into your web app, requiring minimal setup.

• Web SDK: Catalyst’s Web SDK handles permissions and delivery, ensuring your notifications work smoothly without extra effort.

Code snippet to enable push notifications

Paste the provided snippet into your application’s source code:

catalyst.notification.enableNotification().then(resp => {
catalyst.notification.messageHandler = msg => {
    // Write your own action here for what happens when the notification is received.
};
});

Test web push notifications

Once push notifications are configured, test whether they're functioning.

You can do this effortlessly from the console to ensure they're working as expected.

Why this works:

• Catalyst push notifications send and deliver notifications to users.

• Automated push notifications re-engage users based on predictive models like churn risk.

• This eliminates the need to manage complex notification systems, ensuring timely and effective user engagement.

Auto-scaling and performance optimization

With Catalyst, all middleware services scale automatically:

• Authentication, API gateways, QuickML, and push services adjust to traffic demands

• No infrastructure management is required.

• Redundancy ensures high availability without worrying about infrastructure management

• Authentication and API gateways are built in, making it both secure and simple to use.

• The real-time Data Store allows you to easily manage and analyze data.

• QuickML's AI insights let you predict churn to make better decisions.

• Push notifications let you automate user engagement.

• Catalyst is easily scalable and serverless, allowing you to focus on development without worrying about infrastructure management.