Supported App Types

What can run on Keelson?

Keelson is a runtime platform for securely deploying and sharing web apps, APIs, and scheduled jobs within a company or team.

It is particularly well suited to small and medium-sized business applications generated with AI tools such as ChatGPT, Claude, and Manus.

Check whether your app can be deployed

Give an AI agent such as Claude Code, Codex, or ChatGPT the URL of the Keelson Deploy Spec. The agent can use the specification to check whether your app is compatible with Keelson.

https://keelson.dev/docs/reference/deploy-spec.txt

Typical applications include:

• Internal tools for customer, project, or inventory management
• Administration dashboards for viewing and editing data
• Integrations that automate work across Slack, Notion, or Google Sheets
• Lightweight automation such as CSV imports, scheduled aggregation, and alerts
• Back-office workflows such as approval requests and report generation

---

Examples of supported applications

Note

The following are concrete examples of applications that fit Keelson. Each is small enough to be generated with AI and deployed as-is.

Customer and project management

A form, list view, and database make up a typical CRUD business application. Keelson Managed SQLite (libSQL, configured with db.mode: libsql) can provide the durable database without requiring a separately managed database server.

Internal FAQ or search application

A text-search interface backed by an API can make company knowledge searchable. Keelson places authentication in front of the app so it can be shared safely inside the organization.

CSV import and transformation tool

An upload, processing step, and download can automate repetitive data work. A Keelson URL makes the finished tool available to non-developers in a browser.

Approval workflow

A form, status tracking, and notifications can support a small approval flow. Combine it with workspace membership and app access settings to control who can use it.

Daily or periodic report generation

An input form and output template can standardize recurring reports. Scheduled jobs can aggregate the data automatically on a daily or weekly cadence.

Slack, Notion, or Google Sheets integration

A webhook receiver and outbound API calls can synchronize data with external services. The app can combine an HTTP service with scheduled jobs.

Scheduled aggregation batch

An app can consist only of cron jobs. Sales aggregation, log analysis, and notification delivery do not require a user interface or a resident web server.

AI chat or internal RAG interface

A chat interface can call an external LLM API and expose an internal assistant to the team behind Keelson authentication.

---

Runtime and framework support

Keelson is not tied to a specific web framework. A conventional application that can start as an HTTP server can run regardless of its framework.

Supported runtimes

Runtime	Intended use
python-slim	Lightweight Python apps such as APIs and text processing
python-media	Python apps that need image and video libraries
node-slim	Lightweight Node.js apps
node-media	Node.js apps that process media
go-slim	Lightweight Go apps
go-media	Go apps that process media

Supported application forms

• Web app — Starts an HTTP server and serves a browser interface
• API server — Provides a JSON or other HTTP API
• Scheduled job (cron) — Runs a command on a schedule. Background work such as draining accumulated tasks is also expressed as a scheduled job

Examples of compatible frameworks include FastAPI, Flask, Express, Next.js, Hono, and Gin. If the application can be started with the command in keelson.yaml, it can generally run on Keelson.

---

Good fits

Keelson is a good fit when several of the following are true:

• The audience is internal — Access should be limited to a team or company
• Authentication should be managed for you — The application should be protected without implementing its own login flow
• You operate several small apps — One workspace can manage multiple apps
• You want SQLite semantics — Keelson Managed SQLite (libSQL with db.mode: libsql) provides durable storage; local /data is ephemeral
• You want to run an AI-generated app quickly — No Dockerfile is required; deployment is described in keelson.yaml
• Non-developers need access — Users can open the shared URL in a browser

---

Poor fits

Keelson is not optimized for these workloads:

• Very high-traffic public services — Large consumer services are outside the intended scope
• Strict edge-latency requirements — Applications do not execute at CDN edge locations
• Complex distributed systems — Advanced orchestration between many microservices is not the target use case
• GPU-heavy inference — GPU instances are not provided
• Specialized middleware — Apps that require self-managed Redis, external PostgreSQL, Kafka, or similar infrastructure need separate services
• Dedicated infrastructure or strict network topology — VPC peering and dedicated nodes are not initial platform capabilities

Tip

Even if your eventual production system falls into one of these categories, Keelson may still be useful for a prototype or internal validation. You can move the workload when its scale or infrastructure requirements grow.

---

Decision guide: Is your app a fit?

Answer these questions in order for a quick compatibility check.

1. Are the users primarily members of your company or team?

If no, Keelson is probably not the right platform for an unrestricted public consumer service.

2. Does the app provide a web UI or an API?

If no, a cron-only application is still supported. Other execution models are outside the current scope.

3. Does it run on Node.js, Python, or Go?

If no, the required language is not currently among the supported runtimes.

4. Does it require a GPU or specialized middleware such as Redis or Kafka?

If yes, those dependencies are not currently provided by Keelson.

5. Is dedicated infrastructure or strict network control an initial requirement?

If yes, contact Keelson to discuss future Enterprise capabilities.

If the app passes all five checks, it should be a good fit for Keelson.

---

Minimal examples

The following examples show the smallest practical deployment structure.

Python with FastAPI

Directory structure:

my-app/
├── keelson.yaml
├── requirements.txt
└── app.py

keelson.yaml:

slug: my-app
runtime: python-slim
command: "python app.py"
db:
  mode: none

Keelson injects PORT when the app starts. Read it in the application; do not declare it in keelson.yaml.

app.py:

import os

import uvicorn
from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def index():
    return {"message": "Hello from Keelson"}


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

Node.js with Express

Directory structure:

my-app/
├── keelson.yaml
├── package.json
├── package-lock.json
└── index.js

keelson.yaml:

slug: my-app
runtime: node-slim
command: "npm start"
db:
  mode: none
env:
  NODE_ENV: "production"

Keelson installs the dependencies declared in package.json during the build. Generate package-lock.json with npm install and commit it with the source so the build uses the locked versions. Keep command limited to starting the app.

index.js:

const express = require("express");
const app = express();
const port = process.env.PORT || 8080;

app.get("/", (req, res) => {
  res.json({ message: "Hello from Keelson" });
});

app.listen(port, "0.0.0.0", () => {
  console.log(`Listening on port ${port}`);
});

After deployment

When deployment completes, Keelson assigns a URL such as https://my-app.keelson.run/. Only signed-in members who are allowed to use the app can access it at that URL.

---

Frequently asked questions

Do I need a Dockerfile?

No. Select a runtime and provide a startup command in keelson.yaml. Keelson builds the execution environment for you.

Can I host only a frontend or static site?

Yes. Configure assets in keelson.yaml to host built static files.

Can I deploy only an API?

Yes. A JSON API without a user interface is a supported application form.