Systems for teams building with AI

Build platforms
that can prove what they do

PlatformKit is where modular monolith structure, runtime-faithful UI, executable browser contracts, and AI-native developer tooling meet. Less theater, more truth.

SiteSummit FlexspaceDomainsummit.staging.septagon.devExperiencePlatformKit

Read the journal See the architecture

main.gostarter composition live session

live build

package main

func main() {

app := platformkit.New("my-saas",

auth.Module(),

billing.Module(),

tenant.Module(),

admin.Module(),

)

app.Run() // Ready at :3000

}

Bootstrap paused

The starter composition is parked. Restore the window to keep exploring the module graph.

Straight path

Read the work

The public journal stays close to the real platform: architecture, testing, AI tooling, and lessons learned.

quickstart.shguided local boot path

2 commands

Quickstart parked

Reopen the command window when you want the shortest path back to a running flagship surface.

Open journal Browse the system

Inspect modules →See live surfaces →Review plans →

Layered Architecture

Each layer builds on the one below. Start with infrastructure, add modules, build your app — each piece snaps perfectly into place.

Your Application

Complete SaaS · Custom Apps · Any Industry

Business Modules

Auth · Billing · Tenant · Booking · 17+ more

Backend Kit

Entity · CRUD · Events · MCP · Security · API

Infrastructure

PostgreSQL · Redis · NATS · Docker · OpenTelemetry

14+ Composable Modules

Each module is self-contained with its own entities, APIs, admin UI, migrations, and tests. Snap them together to build any SaaS.

Admin Management

admin

1 entities0 features

Api Key Management

security

3 entities0 features

Audit Management

governance

2 entities0 features

Auth Management

security

11 entities0 features

Billing Management

commerce

4 entities0 features

Collection Management

data

2 entities0 features

Content Management

content

3 entities0 features

File Management

core

1 entities0 features

Module Management

core

8 entities0 features

Notification Management

communication

8 entities0 features

Tenant Management

core

7 entities0 features

Theme Management

configuration

2 entities0 features

Translation Management

localization

2 entities0 features

User Management

core

5 entities0 features

Verified from module contracts, admin routes, and MCP-enabled entities

One composition, three surfaces

This is the part most landing pages skip. Compose real PlatformKit modules and you get REST base paths, admin routes, and MCP tools from the same module graph.

verified-module-graph.txtrest + admin + mcp from one graph

verified

module                api base path         admin surface
--------------------  --------------------  --------------------
auth_management       /api/v1/auth          /admin/auth
user_management       /api/v1/users         /admin/users
tenant_management     /api/v1/tenants       /admin/tenants
billing_management    /api/v1/billing       /admin/billing
admin_management      built into app shell  /admin

5 verified module packagessame graph powers app, admin, and agents

Graph parked

Reopen the module graph to inspect how one composition fans out into product, admin, and agent surfaces.

REST surface

Base paths come straight from module contracts, not a handwritten router.

/api/v1/auth/api/v1/users/api/v1/tenants/api/v1/billing

Admin surface

Modules contribute routes into the shared admin shell as they register providers.

/admin/auth/admin/users/admin/tenants/admin/billing/admin

MCP surface

Entities in these modules already expose agent-facing tool names through MCP interfaces.

sessionlogin_attemptemail_verificationuserroletenanttenant_memberworkspaceplan

Impossible-looking, implementation-ready

A launch-film storyboard for the composable platform itself

The page should feel like the product is orchestrating light, motion, and infrastructure in real time. These scenes define the missing media moments that make the whole experience feel beyond normal web constraints.

3 signature momentsPremium atmosphereStructured narrative

Signature sceneVIDEO · 16:9

System orbit opener

An opening motion piece that makes the stack feel assembled, intelligent, and physically present before the first line of copy finishes landing.

hero takeoverherovideocomposition

ARCHITECTURE PROOFComposable stack atlas

IMAGE · 4:5

AI ASSISTANT NARRATIVEOperator and copilot relay

VIDEO · 21:9

01hero takeover

System orbit opener

An opening motion piece that makes the stack feel assembled, intelligent, and physically present before the first line of copy finishes landing.

VIDEO · 16:9herovideocomposition

hero takeoverherovideocomposition

02architecture proof

Composable stack atlas

A still that explains the platform architecture in one glance and gives the proof section something more authoritative than abstract diagrams.

IMAGE · 4:5proofimagearchitecture

architecture proofproofimagearchitecture

03AI assistant narrative

Operator and copilot relay

A narrative bridge between human operator intent and AI execution, built to support the assistant and workflow automation story.

VIDEO · 21:9assistantvideoworkflow

AI assistant narrativeassistantvideoworkflow

A compositional orbit around PlatformKit surfaces, orchestration layers, and AI assistance cues. — hero takeover

Motion cueSlow orbital camera, magnetic light trails, interface planes sliding into a coherent stack.

01video16:9

System orbit opener

An opening motion piece that makes the stack feel assembled, intelligent, and physically present before the first line of copy finishes landing.

A detailed editorial still showing applications, business modules, and shared foundations as one connected platform map. — architecture proof

02image4:5

Composable stack atlas

A still that explains the platform architecture in one glance and gives the proof section something more authoritative than abstract diagrams.

A software operator handing work to an AI copilot across structured platform surfaces. — AI assistant narrative

Motion cueClose-up task handoff, command confirmation states, subtle environment movement, no abrupt cuts.

03video21:9

Operator and copilot relay

A narrative bridge between human operator intent and AI execution, built to support the assistant and workflow automation story.

Production notes

Keep the imagery tactile, dark, modular, and unmistakably PlatformKit

Generated media must feel like part of the product system: graphite surfaces, teal connection light, restrained amber accents, and clean negative space for real HTML copy.

Narrative anchors

Interfaces should show the truth
Tests should execute features
A modular monolith is still my default
Security has to survive the database boundary
Building for AI means designing a second user
Developer experience is product work
Current obsessions
Recent writing
Contact
Admin Management
+13 more anchors kept in the internal media plan

Works with Claude, Cursor, Windsurf, and any MCP client

Build with your AI assistant

platformkit ships an MCP server. Add it to your AI tool and build entire SaaS apps through conversation.

mcp-config.jsonattach your assistant to the workspace

copyable

{
  "mcpServers": {
    "platformkit": {
      "command": "go",
      "args": ["run", "./tools/platformkit-mcp"],
      "cwd": "/path/to/platformkit"
    }
  }
}

Config window paused

Reopen the config to copy the MCP attachment block back into Claude, Cursor, Windsurf, or any compatible client.

mcp-config.jsonattach your assistant to the workspace

copyable

{
  "mcpServers": {
    "platformkit": {
      "command": "go",
      "args": ["run", "./tools/platformkit-mcp"],
      "cwd": "/path/to/platformkit"
    }
  }
}

Config window paused

Reopen the config to copy the MCP attachment block back into Claude, Cursor, Windsurf, or any compatible client.

mcp-config.jsonattach your assistant to the workspace

copyable

{
  "mcpServers": {
    "platformkit": {
      "command": "go",
      "args": ["run", "./tools/platformkit-mcp"],
      "cwd": "/path/to/platformkit"
    }
  }
}

Config window paused

Reopen the config to copy the MCP attachment block back into Claude, Cursor, Windsurf, or any compatible client.

Example conversation

Build me a gym management SaaS with memberships, booking, and billing

I'll compose your app with these modules:

authbillingbookingmembershiptenantadminuser

All dependencies satisfied. Project generated with 7 modules.

Zero to production in 15 minutes

Not an aspiration. A reproducible sequence. Here's exactly what happens.

0:00git clone + make up

Clone the flagship app surface and boot the baseline stack with one supported command

2:00Open Claude Code / Cursor

Connect the MCP server — your AI can now see every module and entity

5:00"Build me a gym SaaS"

AI selects 7 modules, generates config, validates dependencies

10:00Admin panel + APIs live

REST and MCP live. Mobile-ready admin from day one

15:00docker compose up

Production-ready deployment with monitoring and observability

Current obsessions

Runtime fidelity over mock eleganceContracts over smokeModular seams over service sprawlAI as a first-class operator

34+ Integrations

The engineering questions I keep circling back to

Database

PostgreSQLMySQLSQLiteSQL Server

Events

NATSJetStreamWebSocketSSE

Cache

RedisIn-Memory

Authorization

OPARBACEntity-Level

Observability

OpenTelemetryPrometheusJaeger

Jobs

Redis/AsynqCron

Storage

S3MinIOLocalAfero

Payments

StripeFacturalusa

SendGridSMTP

Auth

JWTKratosAuth0

i18n

goi18nJSON

Resilience

Circuit BreakerRate LimitSaga

View flagship source

Modules

Entities

Interface Types

Min to Deploy

Recent writing

A few essays and build notes from the work

Atomic Design Is Not Enough

Atoms and molecules help, but a real platform also has module surfaces, app surfaces, and fidelity boundaries.

Free

✓Component taxonomies explain reuse; they do not explain runtime truth.

✓Base, Modules, Apps, and Tools need different preview contracts.

✓Storybook becomes useful when it stops pretending all UI is the same kind of thing.

Read the essay

Why I Keep Reaching for a Modular Monolith

I still prefer stronger seams inside one system before I reach for service sprawl.

Free

✓Repositories, handlers, contracts, and modules are there to reduce accidental complexity.

✓A modular monolith makes change safer without romanticizing distribution.

✓The point is not ideology. The point is keeping the system legible.

Read the essay

Building For AI Means Designing a Second User

When AI is a real operator inside the repo, context, commands, and boundaries become product surfaces.

Free

✓Prompt glue is not enough once the codebase gets large.

✓Generated context, commands, and agents need to match the actual repo graph.

✓Developer experience becomes part of the platform contract.

Read the essay

The Test Suite Had to Grow Up

Smoke checks were not enough. The platform needed contracts, traces, seeded execution, and honest coverage.

Custom

✓Routes loading is not the same thing as features working.

✓Green only means something when the system executes the behavior it claims.

✓Coverage gaps are often platform-definition gaps in disguise.

Read the essay

Field notes

Short ideas that survived contact with the code

“

A page rendering is not the same thing as a feature working. I trust systems more when they can prove what they do.

Truth before polish

note 01

“

Atoms, molecules, and organisms help with reuse. They do not remove the need for module surfaces, app surfaces, and runtime-aware previews.

Taxonomy is not fidelity

note 02

“

Once AI starts operating inside the repo, commands, context, and permissions become first-class interface design.

AI is another user

note 03

“

Tenant isolation feels more honest when it survives the trip from request context into repository execution and database policy.

The database is part of the security story

note 04

Build platformsthat can prove what they do

Read the work

Layered Architecture

Your Application

Business Modules

Backend Kit

Infrastructure

14+ Composable Modules

Admin Management

Api Key Management

Audit Management

Auth Management

Billing Management

Collection Management

Content Management

File Management

Module Management

Notification Management

Tenant Management

Theme Management

Translation Management

User Management

One composition, three surfaces

REST surface

Admin surface

MCP surface

A launch-film storyboard for the composable platform itself

System orbit opener

Keep the imagery tactile, dark, modular, and unmistakably PlatformKit

Build with your AI assistant

Zero to production in 15 minutes

Recent writing

Atomic Design Is Not Enough

Why I Keep Reaching for a Modular Monolith

Building For AI Means Designing a Second User

The Test Suite Had to Grow Up

Field notes

Build platforms
that can prove what they do