On this page

Architecture Overview#

DevStride is a multi-tenant software-as-a-service application that runs on Amazon Web Services (AWS). It is serverless: the application runs as AWS Lambda functions behind managed AWS services, so there are no servers or containers for us to patch or scale. Its main database is PostgreSQL, hosted by Neon.

This section describes the system as it is built today. It is checked against the code each time it is updated, and was last reviewed on 18 November 2026.

Page What it covers
Application Design The codebase, the backend modules and patterns, the web app, and the API surfaces
Data and Tenancy Where data is stored, how organizations are kept apart, migrations, backup and recovery
Security and Identity Sign-in, single sign-on, permissions, encryption and platform protections
Integrations and Third-Party Services Every outside service the product depends on, and how each one connects
Delivery and Environments Environments, how a change is reviewed, tested and released, and how AI agents take part
Operations and Monitoring Alarms, logs, health checks, canaries and incident response
Costs and Dependencies How running costs are tracked, the software the product is built on, and supply-chain safeguards

The system at a glance#

                     Browser (web app, customer portal, docs sites)
                                       │
            ┌──────────────────────────┼──────────────────────────┐
            ▼                          ▼                          ▼
   CloudFront + S3            API Gateway (HTTP API)        Pusher (real-time)
   web app, media,            sign-in check per request         ▲
   docs sites                          │                        │
                                       ▼                        │
                         Lambda: the shared API function ───────┤
                           (TypeScript, Hono, Node.js 22)       │
                          │            │             │          │
                          ▼            ▼             ▼          │
                    PostgreSQL     DynamoDB      Amazon S3      │
                     (Neon)      (small stores)   (files)       │
                          │                                     │
                          ▼                                     │
              EventBridge bus + SNS FIFO topic ──► SQS queues ──► Lambda consumers
                                                   (one per module: rollups,
                                                   automations, notifications,
                                                   webhooks, integrations, …)

Alongside these sit Amazon Cognito (user accounts and single sign-on), Amazon SES (email in and out), scheduled jobs, the MCP server for AI assistants, DevStride's own OAuth server, and the AI features.

How a request flows#

  1. The web app is a single-page application served from Amazon S3 through Amazon CloudFront.
  2. Each API call goes to an Amazon API Gateway HTTP API. A Lambda authorizer checks the caller's token and lets the request reach only the organizations the caller belongs to and is allowed to sign in to.
  3. Almost every route is served by one shared API function. Each request runs as a command (a change) or a query (a read) inside the module that owns the data.
  4. The command saves its change to PostgreSQL and records the events the change produced.

How an update spreads#

  1. Every change publishes events. Ordinary events go to an Amazon EventBridge bus. Events that must be handled in order, such as moving items in a hierarchy, go through an SNS FIFO topic.
  2. Each module listening for an event has its own SQS queue and Lambda consumer. Those consumers recalculate rollups, run automations, send notifications and webhooks, and sync integrations.
  3. Changes are pushed to open browsers through Pusher, so boards and items update live.
  4. An event that keeps failing goes to a dead-letter queue, which raises an alarm. A recovery job re-sends any event that was saved but not delivered.

Main design choices#

  • Serverless on managed services. Capacity grows and shrinks with use, there is nothing to patch, and the cost of an idle environment is small.
  • One API function, many modules. A single deployable function keeps cold starts and deploys simple. Inside it the code is divided into modules with strict boundaries, so it stays easy to change. See Application Design.
  • Events between modules. A module never reads another module's tables. It asks through a query, changes through a command, or reacts to an event. This keeps modules independent and lets slow work, such as rollups and notifications, run in the background.
  • Infrastructure as code. Every AWS resource is defined in TypeScript with SST version 2, which is built on AWS CDK, and deployed by GitHub Actions. Nothing in production is set up by hand without being recorded and then brought back under code.
  • One shared database, scoped by organization. Every organization's data carries its organization id, and every request is limited to the caller's organizations. See Data and Tenancy.

Where it runs#

  • Region: AWS US East (N. Virginia).
  • Accounts: production runs in its own AWS account. The shared staging environment and developers' personal test environments run in a separate account.
  • Environments: production; one long-lived staging environment that every finished change reaches first; and short-lived personal environments for development. See Delivery and Environments.
Powered by DevStride