A few days ago I wrote about vibe coding with Ulabase: when the backend is already running, an AI can spend the whole session on the product. This post shows one such session, with its commits and timestamps.

The result is Todo Board, a collaborative Kanban app with swimlanes, drag & drop, real-time sync across browsers, group-based sharing, assignees, tags, and mobile support. This is the git log:

13:36  Initial commit — Todo Board (Angular 21 + Ulabase)
13:50  Add group management with saved groups, renaming, and backup
14:35  Add task detail panel with edit functionality
14:39  Externalize RESTHeart URL configuration
14:52  Update README
15:01  Add archived tasks with cleanup and visibility toggle
15:17  Add real-time collaboration via WebSocket
15:34  Add error message when deleting swimlane with tasks
16:12  Fix text wrapping and overflow in kanban cards

Todo Board — real-time collaborative Kanban

That is 9 commits, from 13:36 to 16:12: 2 hours and 36 minutes. From a blank terminal to a working app it took under 3 hours. I did not write a single line of code.

What's in the App

Todo Board does the following:

  • Kanban board with swimlane rows and status columns (Open · In Progress · Blocked · Closed)
  • Drag & drop to move cards between columns and reorder swimlanes
  • Group codes: share an 8-character code with your team, no login required
  • Server-side isolation: RESTHeart ACL ensures each group only sees its own data
  • Real-time sync: changes by teammates appear instantly via WebSocket change streams
  • Assignees, tags, notes on every task
  • Archived tasks: close and forget, restore when needed
  • Backup and restore: export and import group codes as JSON
  • Mobile responsive: task panel slides up as a bottom sheet

The security model is enforced on the server. Every request is scoped by groupId, with readFilter, writeFilter, and mergeRequest applied at the RESTHeart layer. The client never sends groupId explicitly: the backend injects it via mergeRequest. No filtering happens on the client.

The Backend

I asked Claude Code to set up the backend. With the Sophia MCP server connected, it queried the Ulabase documentation for collections, JSON Schema validation, ACL syntax and change stream configuration. It generated init-backend.sh, a single script that provisions the entire backend, and ran it.

The script works in five steps:

1. Create the collections and schema store

http PUT "$URL/todos"     -a "$AUTH"
http PUT "$URL/swimlanes" -a "$AUTH"
http PUT "$URL/schemas"   -a "$AUTH"

2. Define a JSON Schema for task validation

{
  "properties": {
    "title":   { "type": "string" },
    "status":  { "type": "string", "enum": ["open", "in-progress", "blocked", "closed"] },
    "groupId": { "type": "string" }
  },
  "required": ["title", "status", "createdAt"]
}
http PUT "$URL/schemas/todo" -a "$AUTH" < schema.json
http PATCH "$URL/todos" -a "$AUTH" jsonSchema:='{"schemaId":"todo"}'

3. Apply ACL rules for server-side group isolation

http PUT "$URL/acl/todoUserCRUD" -a "$AUTH" \
  roles:='["$unauthenticated"]' \
  predicate='path-prefix("/todos") and qparams-contain(groupId)' \
  priority:=100 \
  mongo:='{
    "readFilter":   {"groupId": "@qparams['"'"'groupId'"'"']"},
    "writeFilter":  {"groupId": "@qparams['"'"'groupId'"'"']"},
    "mergeRequest": {"groupId": "@qparams['"'"'groupId'"'"']"}
  }'

Every read and write is automatically scoped to the caller's group. The mergeRequest injects groupId into every new document, so the client never sends it explicitly.

4. Create WebSocket change streams

STREAM='[{"uri":"changes","stages":[
  {"$match":{"$or":[
    {"operationType":"delete"},
    {"fullDocument::groupId":{"$var":"groupId"}}
  ]}}
]}]'
http PATCH "$URL/todos"     -a "$AUTH" streams:="$STREAM"
http PATCH "$URL/swimlanes" -a "$AUTH" streams:="$STREAM"

The stream is filtered server-side: only events belonging to the caller's group are pushed over the socket. $var: groupId is resolved at runtime from the query parameter.

5. Gate stream access with a dedicated ACL rule

http PUT "$URL/acl/todoUserStreams" -a "$AUTH" \
  predicate='(path-prefix("/todos/_streams") or path-prefix("/swimlanes/_streams"))
             and qparams-contain(avars.groupId)'

When the script finished, the terminal showed:

✓ todos collection (201)
✓ swimlanes collection (201)
✓ schemas store (201)
✓ todo schema (201)
✓ schema applied to todos (200)
✓ ACL todos (201)
✓ ACL swimlanes (201)
✓ ACL streams (201)
✓ todos change stream (200)
✓ swimlanes change stream (200)

✓ Backend initialized successfully!

At this point the collections, the JSON Schema validation, the group-scoped ACL and the real-time WebSocket endpoints were all running. Claude Code took a few minutes to write the script, using the Sophia MCP server for the exact syntax. The script ran in about 10 seconds.

The backend was working before the frontend had rendered a single component.

The Session

I started at 13:36 with a single prompt:

Build a collaborative Kanban board. Angular frontend, Ulabase backend. Group-based access — users share a code, no login required. The board should have swimlane rows and status columns.

Claude Code, with Sophia MCP connected, first queried the documentation on how Ulabase handles collections, ACL, and change streams. Then it generated init-backend.sh, ran it against my Ulabase instance, verified the responses, and moved on to the Angular app.

By 13:50 the board was rendering tasks. By 14:35 there was a full task detail panel. I expected real-time sync across browsers via WebSocket to take the longest. It was done at 15:17, less than two hours in.

The WebSocket implementation uses RESTHeart's native change streams, filtered server-side:

{ "$match": { "$or": [
  { "operationType": "delete" },
  { "fullDocument::groupId": { "$var": "groupId" } }
]}}

The server only pushes events that belong to the caller's group. The $var reference is resolved at runtime from the query parameter. A dedicated ACL rule gates access to the stream endpoints. Claude Code got this right on the first try. It had the current documentation at hand.

What Made This Possible

Two sources of friction in vibe coding were absent from this session.

Backend friction. Normally the AI has to choose a stack, generate server code, set up a database, work out authentication and handle deployment. Each decision is a guess, and each wrong guess costs debugging time.

With Ulabase those decisions were already taken. Collections, permissions and real-time streams are configured with API calls, as the script above shows. Claude Code had a declarative API to generate against.

Documentation friction. The AI's training data has a cutoff. RESTHeart's API has specific syntax for ACL predicates, for $var references in change streams and for mergeRequest. A mistake in any of these produces a 400 error with no obvious fix.

Sophia MCP covered this. Claude Code retrieved the current documentation at query time via semantic search, so it worked from the docs as they are today.

Try It

The app is live at todo.softinstigate.com. The source is on GitHub under the Apache 2.0 license.

If you want to run your own instance:

  1. Create a free Ulabase service at ulabase.com
  2. Connect Claude Code to Sophia:
    claude mcp add --transport http ulabase-docs https://d0c5a1.ulabase.app/mcp
    
  3. Clone the repo, run init-backend.sh against your instance, configure the URL, and deploy

Ulabase is a MongoDB Technology Partner. Sophia is an AI knowledge base built on Ulabase: try it live.

Build your app on Ulabase

Your backend is ready in minutes, and you spend your time on your app. The Free plan needs no credit card.