TakeSix

Example

An architecture diagram you can click into

An architecture overview usually ends up as one huge diagram nobody can read, or a dozen pages of docs. Here the whole system fits on one screen: the layers a request passes through run from top to bottom, and operations stand beside them. Click a block to see its parts, and a part to read about it.

Open in the editor

SaaS web app architecture

A typical web product, layer by layer: a request goes from top to bottom, operations beside. Click a block to see its parts

๐Ÿ–ฅ

Clients

Web, mobile and partner apps

โฌก

Platform

Edge in front, application services behind

๐Ÿ“ˆ

Operations

Logs, metrics, alerts, deploys

๐Ÿ—„

Data

PostgreSQL, Redis, files, search index

Get one like it from your agent

With the TakeSix MCP server or skill connected (see the guide), ask in plain words:

Prompt
Explain the architecture of this repository as a TakeSix diagram: the main layers on the first screen, their parts inside, and only the links that matter.
Read this diagram as text
  • Clients: Web, mobile and partner apps
    • Web app: React single-page app

      Built and deployed to the CDN as static files. Talks to the API over HTTPS with a session cookie. It uses the same public API as every other client, with no private shortcuts.

    • Mobile apps: iOS and Android

      Native apps with OAuth tokens. Push notifications come from the notification worker.

    • Partner API: Integrations with API keys

      Partners call the same REST API with an API key per workspace. Rate limits are stricter than for first-party clients.

  • Platform: Edge in front, application services behind
    • Edge: CDN, firewall, API gateway
      • CDN: Static files and caching

        Serves the web app and public images. Cache keys include the build hash, so a deploy never serves stale code.

      • Firewall: WAF and bot protection

        Blocks known attack patterns and abusive bots before they reach the gateway.

      • API gateway: Routing, rate limits, auth check

        The only way in from the internet: everything behind it lives in a private network. - Routes `/api/*` to the services - Rate limits per user and per API key - Rejects requests without a valid session or token, so services can trust the caller

    • Application: Services and background jobs
      • Billing: Plans and payments via Stripe

        Handles Stripe webhooks and keeps the current plan of each workspace. The core API asks it for limits.

      • Core API: Workspaces, projects, users

        The main REST API. Writes go to PostgreSQL in a transaction; every change also publishes an event for the workers.

      • Auth: Sign-in, sessions, OAuth

        OpenID Connect with Google and GitHub, email magic links, sessions in Redis. Issues the tokens the gateway checks.

      • Search: Full-text search over projects

        Reads from the search index; the index is filled by a worker from core API events.

      • Background jobs: Queue, workers, scheduler: slow or retryable work
        • Scheduler: Nightly and hourly jobs

          Cleans up expired sessions, sends digests, reconciles billing with Stripe.

        • Queue: Events from the services

          The services publish events here, so nothing slow runs inside a request. Durable queue with retries and a dead-letter queue for jobs that keep failing.

        • Workers: Emails, exports, indexing

          - Sends emails and push notifications - Builds CSV and PDF exports - Updates the search index

  • Data: PostgreSQL, Redis, files, search index
    • PostgreSQL: Primary and read replica

      Source of truth for workspaces, projects, users and billing state. Point-in-time recovery for 14 days. Backed up nightly, with a hot replica for reads and failover.

    • Redis: Cache and sessions

      Short-lived data only: losing it logs users out, nothing more.

    • Object storage: Uploads and exports

      S3-compatible bucket. Files are served through signed URLs that expire after an hour.

    • Search index: Rebuilt from events

      Can be dropped and rebuilt from PostgreSQL at any time.

  • Operations: Logs, metrics, alerts, deploys
    • Observability: Logs, metrics, traces, alerts

      Structured logs, metrics with alerts on error rate and latency, distributed traces across the gateway and services.

    • CI/CD: Tests, builds, deploys

      Every merge to main runs tests, builds images and deploys to staging; production deploys are one click.

    • Infrastructure as code: Environments from code

      Networks, databases and services are described in code and reviewed like any other change.

More examples