Technical Case Study

Building a community event platform with Alani Insights.

Palm Beach Tech Week is a community-led week of events in West Palm Beach, April 10 to 16, 2027. Its website takes event submissions from many organizers, lets a few volunteers approve them, and publishes an open calendar.

It has no database server to run, and the only admin tool built for it is a small review page with a few buttons. The records live in Alani Insights, where organizers view and edit them, and the site reads and writes them over the REST API. This page documents the implementation as deployed on November 21, 2026.

Organization Palm Beach Tech Week
What it is Open event calendar with approvals
Site stack Astro on Netlify
Database Alani Insights, REST API

Disclosure. bundleIQ makes Alani Insights. bundleIQ also built and operates pbtechweek.com in support of the week's organizing committee. This is a first-party account of our own implementation, not an independent customer review.

The Challenge

Many hosts, a few reviewers,
and nobody to run a database.

A decentralized event week has no single owner of the schedule. Companies, funds, labs, universities and community groups each host their own event. The site had to collect them, let a small volunteer team decide what belongs, and publish the result, built and run by one developer, part time.

📥

Take submissions from anyone

A full event submission from a host with a venue and a date, and a one-line idea from anyone with a preferred day.

🔒

Keep contact details private

Reviewers need each submitter's name and email to follow up. The public calendar must never show them.

🗓️

Publish without a redeploy

A confirmed event should reach the calendar within minutes, with no code change, and the page should stay up if the database does not.

Why Alani Insights

One database.
Two ways to work with it.

Palm Beach Tech Week needed more than somewhere to store submissions. It needed records that software could read and write, and that organizers could open and correct without a separate database tool. Alani Insights provided three things together.

🗄️

Its own database

Palm Beach Tech Week's events, people and organizations sit in its own provisioned database, separate from other organizations' records, as tables with described fields. Nothing to host, patch or back up.

🧑‍💻

An interface for people

Organizers can open and edit the same records in the Insights app in a browser. We did not build table views or record editing.

🔌

One interface for software

The website reads and writes those records over REST. An authorized AI assistant could reach the same tables over MCP. This site does not use that today.

What we wrote

  • One function that files each submission
  • The page that draws the calendar and applies the publishing rules
  • A small private dashboard for review

What we did not build

  • Database infrastructure and its upkeep
  • A general-purpose screen for viewing and editing records
  • An API in front of the data

Insights is the database and the interface to it. It is not the application: the forms, the scoring call, the publishing rules and the review dashboard are the site's own code.

The Events table in the Alani Insights app, showing six event submissions with their titles, the status shown_idea, and their formats
The Events table in the Alani Insights app on November 21, 2026, filtered to the six submissions an organizer approved as ideas. These are the records the public calendar reads. Contact fields are out of frame.
See It Working

From a form to the calendar,
with a person in between.

Someone proposes an event. It becomes a record the organizers can see. An organizer approves it, and it appears on the public calendar. Four parts do that work, and none of them is specific to events. The whole approval system is one status field with five values: submitted, idea, shown_idea, confirmed and hidden.

1

A form handler writes one record

Each submission becomes one described record in the Events table, with a starting status and a link to the person and organization.

2

A model scores it for the queue

Host submissions get a 1 to 10 fit score, a verdict and a reason. The score sorts the review queue. It is not moderation. Nothing a visitor submits is public until a person shows it as an idea or confirms it.

3

The calendar applies explicit rules

The page reads the table and decides in code what is public: which records, and which fields of each. The database stores the records and the site decides.

4

A protected action changes the status

Confirm, Show as idea, Hide and Restore on a private dashboard each send one request that changes one field on one record.

The Architecture

What runs where, and what
Insights actually handles.

Insights is the database and nothing more. Netlify handles the forms and the server functions, Anthropic's API handles scoring, and the website's own code holds the publishing rules.

Architecture of pbtechweek.com: four public forms post to Netlify Forms; a submission-created function scores host submissions with a language model and writes to the Events, People and Companies tables in Alani Insights over REST; the server-rendered calendar reads Events; a password-protected dashboard patches the status field; anchor and featured events come from a file in the repository.

Four public forms

Static HTML forms handled by Netlify Forms. Netlify stores every submission, so a failed sync never loses one.

One server function

Triggered by Netlify on every submission. It finds or creates the person and the organization, scores host submissions, and creates the event record.

A scoring call

Claude Haiku 4.5, called through Anthropic's API with a written rubric. It returns a 1 to 10 score, a verdict and a short reason, stored on the event. It does not go through Insights.

Alani Insights

Hosted tables: Events, People and Companies. The system of record for submissions, reached over the REST API with one server-side key.

The public calendar

A server-rendered page and two calendar feeds. They read Events, apply the publishing rules in code, and render public fields only.

A private dashboard

A password-protected page with the review queue. Confirm, Show as idea, Hide and Restore each send one PATCH that changes one field.

A file in the repository

Anchor events and featured listings are kept in the site's own code.

Results

An early deployment,
stated as it is.

These are the figures on November 21, 2026, for a working system run by a small volunteer team.

8
events submitted through the host form since October 2026
6
of those approved by an organizer and shown on the calendar as ideas
36
newsletter signups stored as people
44
people in the workspace, each matched by email

No agent is part of this workflow. The same tables are reachable through the Insights MCP server, but the deployed site uses REST only. The one model call, scoring, goes straight to Anthropic's API.

The open calendar on pbtechweek.com on November 21, 2026: a week grid for April 10 to 16 with four anchor events in dark blocks, one confirmed event in orange, and five ideas in dashed outlines.
The calendar on November 21, 2026. The dashed blocks are host submissions read from the Events table and shown as ideas.
Technical Implementation

The rest of this page is reference: the schema, the API calls, the publishing rules and the approval mechanics, for anyone who wants to reproduce it.

Data model

Three tables are in use. The workspace was started from the Insights CRM template, which also created Opportunities and Activities tables; the site does not use them and they are empty.

Events

One record per proposed event. 32 fields including id and created_at. Every field the site writes is type text.

Field Set by Used for
title Form Public
status Form at creation, then the dashboard The whole workflow. See status values
source Form pbtechweek.com/host or pbtechweek.com/calendar. The site ignores records with any other value
description Form Public, shortened to 400 characters
organization Form Public, as the host
preferred_day Form Text such as Tue Apr 13, or TBA. The calendar parses the day number out of it
start_time, end_time Form HH:MM, or TBA. Idea records hold a part of the day in start_time: Morning, Midday, Afternoon, Evening
venue_status, venue_name, venue_address Host form venue_name is public once confirmed
registration_url Host form Public once confirmed, and only if it is an http or https link
format, audience, partners, capacity, admission, placeholder_copy, host_notes, backup_day Host form Review only
listing_consent Form yes when the submitter agreed to a public listing
host_name, host_email Form Private. Never rendered on a public page
host_person_id, company_id Function The ids of the linked People and Companies records, stored as text
fit_score, fit_verdict, fit_reason, fit_model Function, from the scoring call Sorting and context in the review queue. Nothing else
review_notes People, in the Insights app Internal notes

People

The CRM template’s People table plus four fields added for the site: interest, source, tags and email_opt_in. One record per person, matched by email. Newsletter signups, hosts, idea submitters and contact-form senders all land here, distinguished by comma-separated tags such as newsletter, host, idea, contact. A contact-form message is appended to the person’s notes.

company_id on People is a real foreign-key field pointing at Companies.

Companies

The template’s Companies table plus org_type and source. One record per host organization, matched by name.

Relationships

Companies  <-- People.company_id (foreign key)
People     <-- Events.host_person_id (text holding an id)
Companies  <-- Events.company_id     (text holding an id)

The two links from Events are text fields that hold the id of the linked record.

Status values

status Set by Meaning
submitted Host form Waiting for review. Not public
idea Idea form Waiting for review. Not public
shown_idea Dashboard: Show as idea On the public calendar as an idea: proposed, not yet a confirmed event
confirmed Dashboard: Confirm On the public calendar as a confirmed event
hidden Dashboard: Hide Never shown publicly

Restore sets a hidden record back to idea or submitted, depending on which form created it.

How a submission is written

The function receives Netlify’s submission payload and makes these calls. {events}, {people} and {companies} stand for table ids, which the function looks up once by name.

GET  /v1/tables
GET  /v1/tables/{companies}/records?name=<organization>&modifiers[limit]=1
POST /v1/tables/{companies}/records                        (if not found)
GET  /v1/tables/{people}/records?email=<email>&modifiers[limit]=1
POST /v1/tables/{people}/records                           (if not found)
PATCH /v1/tables/{people}/records/{id}                     (if found: merge tags, append a note)
POST /v1/tables/{events}/records

A person or an organization matches only when the value is equal after trimming and ignoring capitals. The lookup asks for the value as typed; if nothing comes back it fetches up to 25 candidates with a case-insensitive search and accepts one only on that exact comparison. Otherwise it creates a new record. Emails are stored trimmed and lowercased.

Every request carries the header x-api-key. The event record for a host submission looks like this, with synthetic values:

{
  "title": "Robotics Lab Open House",
  "status": "submitted",
  "source": "pbtechweek.com/host",
  "format": "Lab or facility tour",
  "description": "Tour a working robotics lab and watch three student teams demo their builds.",
  "preferred_day": "Tue Apr 13",
  "start_time": "17:30",
  "end_time": "19:30",
  "venue_status": "Have a venue",
  "venue_name": "Engineering Hall",
  "organization": "Example Coast University",
  "host_name": "Dana Whitfield",
  "host_email": "dana.whitfield@example.edu",
  "host_person_id": "<id of the People record>",
  "company_id": "<id of the Companies record>",
  "listing_consent": "yes",
  "fit_score": "8",
  "fit_verdict": "strong",
  "fit_reason": "A real lab opening its doors, with demos from named teams.",
  "fit_model": "claude-haiku-4-5"
}

Three details matter if you copy this:

  • Only known, non-empty fields are sent. Empty values are dropped before the request, and the function writes only fields that exist as columns, so the function and the table’s columns change together.
  • Scoring cannot block the write. If the model call fails or no model key is set, the record is saved with fit_verdict set to unscored and the reason. A separate script backfills scores later.
  • The function always returns success to Netlify. A failure is logged, and the submission is still in Netlify Forms to replay by hand.

How the public calendar reads

/calendar is rendered on the server for each request. It reads the whole Events table, 500 records per page:

GET /v1/tables/{events}/records?modifiers[limit]=500&modifiers[offset]=0

Pagination uses modifiers[limit] and modifiers[offset].

The result is held in memory for two minutes per function instance. If the request fails, the page uses the last good copy, and if there is none it renders the anchor and featured events from the repository file. The page does not depend on Insights being reachable.

Reading the table once and filtering in code keeps it simple: one request, one cached result, and every rule in one place.

Filtering happens in the site’s code after the read, not in the query:

  1. Keep records whose source is one of the two forms.
  2. Drop records already featured in the repository file.
  3. Publish as an idea: a record with status shown_idea, which only the dashboard sets. Records still waiting, with status submitted or idea, are never published.
  4. Publish as confirmed: a record with a confirmed status. A host submission, shown either way, also needs the submitter’s consent to a listing.
  5. Reduce every published record to title, day, time, description and organization. A confirmed record also gets its venue name and registration link, and only confirmed records go into the .ics feeds.

Nothing a visitor submits reaches the calendar until a person has looked at it. The model’s score orders the review queue and does nothing else. It is not moderation and it is not a security control, and no publishing rule reads it.

How approval works

/dashboard lists what is waiting, sorted by fit_score, with the model’s reason beside each item. Each button posts a record id and a target status. The server then:

  1. Fetches the record and refuses to continue unless its source is one of the two forms.
  2. Sends one request: PATCH /v1/tables/{events}/records/{id} with {"status": "confirmed"} (or shown_idea, hidden, idea, submitted).
  3. Clears the calendar’s in-memory copy so the change shows on the next request.

That is the entire approval system: one field, five values, one PATCH.

Authentication and permissions

  • One API key. It is stored as an environment variable on the hosting platform and read only by server-side code. It is not in the repository and never reaches a browser.
  • The site’s code is the gatekeeper for the public. Visitors never talk to Insights. They post a form, and the function decides what gets written.
  • The dashboard has its own sign-in. A shared password, a signed session cookie that lasts eight hours, a lockout after five wrong attempts from one address, and headers that keep the page out of search and out of frames. Insights is not involved in that sign-in.
  • Organizers who use the Insights app sign in to Insights separately and can edit any record in the workspace there.

How people work with the data

  • In the dashboard, for the routine decision: show as an idea, confirm, or hide.
  • In the Insights app, for anything else: fixing a title, adding review_notes, merging a duplicate organization, or adding a record by hand. One event in the table was entered by hand rather than through a form.
  • Through the API, for maintenance scripts such as the score backfill.

Agents and MCP

Alani Insights has a remote MCP server that exposes the same tables to assistants such as Claude and ChatGPT, with tools to list tables, describe a table, and search, create, update and delete records. Because the Events table carries written descriptions of its fields and status values, an assistant connected to this workspace would have what it needs to answer “what is waiting for review?” or to change a status.

The deployed site uses REST only, and no agent takes part in the workflow.

Results

As of November 21, 2026:

  • The submission path has run in production since October 2026. Netlify recorded 8 host submissions and 36 newsletter signups, and the workspace holds 8 host-form event records and 36 people whose source is the newsletter form.
  • Seven of the eight host submissions were scored by Claude Haiku 4.5 at submission time and the first one by a different Claude model, before the model was changed. The verdicts were four strong, three maybe and one weak.
  • A submission is public only after an organizer shows or confirms it on the dashboard. An organizer has approved six of the eight as ideas and hidden one.
  • The site code that talks to Insights is about 170 lines for reading and status changes, and about 215 lines for the submission function.

Reproduce the pattern

The pattern is four parts, and none of them is specific to events:

  1. A form handler that writes one described record per submission, with a starting status.
  2. A table where one field carries the workflow.
  3. A page that reads the table and applies explicit publishing rules in code.
  4. A protected action that changes the status.

examples/event-platform in our public examples repository runs all four parts against synthetic data, in about 200 lines of Python with no dependencies. It creates the tables with field descriptions, files seven submissions without duplicates, prints the review queue, lets a reviewer confirm one, show two as ideas and hide one, and writes the public view. Before any review, nothing is public. It uses a keyword rule where the real site calls a model, and foreign keys where the real site stores ids as text. The repository is MIT licensed.

You can build the same thing on any store that gives you an HTTP API and a way for people to see the rows. What to look for: can a server function write to it without a driver, can non-developers open and edit the records, and does the schema carry enough description that the next person, or an assistant, can read it without asking you.

Questions about this implementation: hello@bundleiq.com

Reproduce It

Run the same four parts
on synthetic data.

A form handler, one table with a status field, a page that applies explicit rules, and a protected action. Alani Insights supplies the tables, the API your server calls, and the app where your team opens the same records.