Quickishquickish_

Features

Everything Quickish does, in one place.

Start with a folder of HTML and a live URL. When you want more, a backend, real data, server code, your own domain, it's already there. No build step, no servers, nothing to wire up.

Instant hosting Publish with AI Data & backend Functions quick.sql Sharing Custom domains Localish Develop locally

Instant hosting

Give any folder of HTML a live URL.

Drop a file, a whole folder, or a zip, or run one command, and your page, site, or deck is online in seconds. Links between files just work, relative paths and all.

  • No build step, no config, no server
  • Drop an .html or .zip on the home page and it's live, no signup
  • A lone PDF, Markdown, CSV, or image gets a clean in-browser viewer
Read the Pages docs →
terminal
$ npm i -g quickish
$ quickish            # publish this folder
✓ live · you.quickish.site

Publish with AI

Just ask your assistant to publish it.

AI makes good-looking HTML, and it usually has nowhere to live. Connect Quickish once, then say “publish this to Quickish” and your page goes live, assets and all. No blank page either, remix a ready-made app and have any agent refine it.

  • A Claude connector or a custom ChatGPT GPT, sign in once
  • Remix a ready-made app, then have any agent make it yours
  • Coding agents publish with the quickish CLI
  • Claude can even build a stateful app and seed its data for you
Read the AI docs →
Claude
Your presentation is ready.
publish it on Quickish
Reply to Claude…

Data & backend

A real backend in one line.

Add one script tag and your page gets quick.db (a document store), file uploads, the signed-in visitor, live updates, and casting to a screen, with no keys to manage.

  • Store and read JSON, with live updates over websockets
  • Sensible permissions: visitors read, only you write, until you say otherwise
  • Cast a page to a TV and push to it from your phone
Read the Data docs →
index.html
<script src="/quick.js"></script>

const tasks = quick.db.collection("tasks");
await tasks.create({ title: "Ship it" });
const all = await tasks.list();   // done.

Functions

Server-side code that keeps secrets.

Drop a file in a functions/ folder and it becomes a server-side endpoint, so it can hold a secret API key, tally a vote nobody can stuff, or validate input before it touches your data.

  • One file is one function, call it from your page with quick.fn()
  • Secret keys live only on the server, never in the browser
  • The source never ships to visitors
Read the Functions docs →
functions/checkout.js
export default async function (req, { env, db }) {
  // env.STRIPE_SECRET stays on the server
  const order = await db.collection("orders")
    .create({ items: req.body.items });
  return { ok: true, id: order.id };
}

quick.sql

A real SQL database, zero setup.

When your data grows relations, a leaderboard, a kanban, anything with joins, reach for quick.sql. It's managed Postgres behind one tagged-template call. No connection string, no provisioning.

  • Query right from your page, values are always safely bound
  • Declare your schema in a sql/ folder; migrations run once at deploy
  • Each site gets its own isolated schema
Read the quick.sql docs →
leaderboard.html
const top = await quick.sql`
  select name, sum(points) as pts
  from scores group by name
  order by pts desc limit 10`;

Sharing & permissions

Share it your way, public or just you.

Every page can be private, shared with named people, company-wide, or fully public, and Quickish picks safe defaults so a public page is never a free-for-all.

  • Flip visibility per page, in the dashboard or with a CLI flag
  • AI drafts land as a private preview, promote them in one click
  • Remix an app you like into your own copy
Sharing  ·  Permissions
terminal
$ quickish --private              # only you
$ quickish --invites a@co.com     # named people
$ quickish --workspace            # your company
$ quickish --public               # anyone

Custom domains

Serve it at your own address.

Point your own host at a page and serve it at docs.acme.com instead of a Quickish URL, with an HTTPS certificate issued automatically. Your backend keeps working, untouched.

  • Add two DNS records, verify once, it goes live
  • The same access rules apply, a private page stays private
  • quick.db, quick.fn, quick.sql, and realtime all keep working
Read the Domains docs →
terminal
$ quickish domains add docs.acme.com --path docs
# add the two DNS records it prints, then:
$ quickish domains verify docs.acme.com
✓ live · https://docs.acme.com

Localish New

Your localhost, live at a private URL.

Run quickish --localish and your running dev server gets a stable, private, sign-in-gated Quickish URL, hot reload and all. No deploy, no third-party tunnel, nothing exposed to the public web.

  • One command tunnels localhost to a real, sign-in-gated URL
  • Hot reload works through the link, Vite and Next included
  • Hand a coding agent a URL to watch its own changes land
Read the Localish docs →
terminal
$ quickish --localish        # tunnel your dev server
 tunneling localhost:5173
✓ live · you.quickish.site/_localish/app/

Develop locally New

Run the whole backend on your machine.

quickish dev emulates all of Quickish offline, quick.db, quick.sql, functions, file uploads, identity, and realtime, so you (or an AI agent in a sandbox) can build and test a real stateful app with no account and no network, then publish it unchanged.

  • The real client SDK, served from your own machine, so nothing drifts
  • Auto-runs your Vite or Next dev server and proxies it, HMR included
  • Snapshot the local data, switch the signed-in user, or reset, no restart
Read the dev docs →
terminal
$ quickish dev        # backend, offline
 quick.db · quick.sql · quick.fn · files
✓ localhost:4321 · no account, no network

$ quickish            # ship it, unchanged

Make something live.

Free for one live page per person. Drop a file, run a command, or just ask your AI.

Get started free Read the docs