Where Does Pendulum Fit In?

Design Principles

While many BaaS platforms require developers to write custom functions for basic operations, Pendulum's philosophy is that a Backend as a Service should eliminate backend complexity, not shift it to the developer. We identified a few core principles that guided our design of Pendulum to deliver on this philosophy.

Reactivity and Automatic API Endpoints

Some BaaS platforms like Convex require developers to write custom functions for every database operation, resulting in significant boilerplate code. This happens because, instead of dedicated REST API endpoints reached via HTTP, Convex uses a WebSocket connection for both database operations and real-time updates. While this approach allows for faster real-time updates, we identified a key drawback: most applications need standard CRUD operations that shouldn't require custom backend code.

Pendulum provides automatically-generated REST API endpoints for all database operations with real-time updates enabled by default — a single frontend method for subscribing to real-time updates makes your app reactive.

Here is how a frontend developer would fetch and sort a paginated result from the backend using Convex:

// convex/tasks.js
import { query } from "./_generated/server";
import { v } from "convex/values";

export const getTasks = query({
  args: {
    limit: v.optional(v.number()),
    offset: v.optional(v.number()),
    sortBy: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    const { limit = 20, offset = 0, sortBy = "description" } = args;

    let query = ctx.db.query("tasks");

    // Apply sorting
    query = query.order("asc", sortBy);

    // Manual pagination handling - no built-in offset with Convex
    const allResults = await query.collect();
    const paginatedResults = allResults.slice(offset, offset + limit);

    return {
      tasks: paginatedResults,
      hasMore: offset + limit < allResults.length,
      totalCount: allResults.length
    };
  },
});

// frontend component
import { useQuery } from "convex/react";
import { api } from "../convex/_generated/api";

export function TaskList() {
  const tasks = useQuery(api.tasks.getTasks);

  return (
  ...
  );
}'

Here we accomplish the same task with Pendulum using just a single method invocation. Most importantly, all of the code needed for this operation is confined to the frontend.

// frontend component
import { PendulumClient } from "@pendulum-baas/sdk";
const client = new PendulumClient();

export function TaskList() {
  const [tasks, setTasks] = useState([]);

  useEffect(() => {
    const loadTasks = async () => {
      const result = await client.db.getSome("tasks", 20, 2);
      setTasks(result.data);
    });

    loadTasks();
  }, []);

  return (
  ...
  );
}

Reactivity Explained

Traditional web apps show stale data - users have to refresh to see changes. Reactivity means your app automatically updates when backend data changes. With Pendulum's reactivity, your app feels alive! Watch how changes made by one user instantly appear for everyone else: when one user creates, updates, or deletes data, other users see these changes reflected in their application immediately.

Automated Cloud Deployment

We wanted Pendulum to be easy for developers to quickly develop and deploy applications on AWS. With a simple set of terminal commands, Pendulum handles deploying frontend code alongside a scalable, containerized backend to an isolated VPC in the user’s AWS account. There, users manage application data through an intuitive dashboard where data lives entirely in their AWS account.

Flexible Data Schema

Solo developers and small teams often don't know their exact data requirements upfront. Pendulum's flexible data schema allows developers to start with simple schemas that can evolve organically as application requirements take shape - new fields can be added to documents without affecting existing data or requiring migrations.

Core Components

These design principles are implemented through Pendulum's four core components:

Backend

The Pendulum backend is made up of two main services:

Application Service — Responsible for handling all CRUD operations, data validation, authentication, and authorization. This service exposes REST API endpoints for database operations, user management, and permission validation.

Events Service — A real-time events server dedicated to maintaining persistent connections with clients and distributing database change notifications to all subscribed applications.

Admin Dashboard

The admin dashboard is the developer’s window into the Pendulum backend. Developers can manipulate backend data, view real-time system logs, monitor database operations, and configure collection-level access controls all in one place.

Command-Line Interface (CLI)

The Pendulum CLI automates the entire development workflow. With four simple commands, developers can initialize a Pendulum-backed project, start the local development environment, and provision or teardown AWS resources in deployment.

Software Development Kit (SDK)

Pendulum’s SDK is the interface to the Pendulum backend. Developers import the SDK client into their frontend code and create a new instance of the PendulumClient. With this, a frontend application automatically connects to the Pendulum backend, and developers get access to methods for standard CRUD operations and real-time data synchronization.

AI Integration (MCP Server)

The Model Context Protocol (MCP) server bridges Pendulum backends with AI assistants (e.g., like Claude Desktop), enabling developers to gain insight into their production systems through natural language queries. Developers can simply ask "How many users are currently connected?" or "Generate a schema for my `users` collection." and get answers through a familiar AI interface.

The MCP server provides backend system monitoring, schema inference and validation, and real-time event snapshots — all accessible through conversational AI interfaces that developers are already using for coding assistance.

Pendulum in the BaaS Space

With these core components, Pendulum is designed for solo developers and small teams who want to build reactive applications quickly without writing custom backend code. Here's how Pendulum compares to other popular BaaS solutions: