Summary: On August 12, 2026, Neon announced Functions: Node.js 24 fetch(request) on the same region and branch as their Lakebase Postgres (Neon’s database—not Databricks Lakebase), with DATABASE_URL injected. That is colocation for SELECT. It is not a multimodal data table. A function is always requested and always returns a web response. Insert a video and nothing runs until someone hits the HTTPS URL. Pixeltable’s unit of work is a computed column: insert → frames, transcripts, embeddings stay consistent. pip install pixeltable.
What Neon Announced#
Functions are serverless Node compute you deploy onto a Neon branch. Fair, and useful if your problem is “my Lambda talks to Postgres over the public internet”:
- Same region as the branch;
DATABASE_URL(and Object Storage / AI Gateway creds) land inprocess.env. - Isolates stay up across requests, so you keep a module-scope
pgPool instead of opening a connection per invoke. - Long-running enough for agent streams, WebSockets, and SSE.
- Declared in
neon.ts; a child branch gets its own function ID and URL.
Neon is explicit about the limits. Functions are not frontend hosting. They are not a background job runner—pair with something like Inngest for queued work. Cron, storage events, and other triggers are still WIP. That last sentence is the product: request/response next to SQL, not a pipeline that runs because data arrived.
The fetch() Problem#
What happens to the data when nobody calls fetch()? Nothing. Colocation cuts a network hop. It does not extract frames, transcribe audio, or keep an embedding index in sync. Agents and SSE are serving problems. Insert / recompute / search is a data problem.
Microsoft’s pg_durable put durable SQL steps inside Postgres. Neon Functions put a Node handler next to Postgres. Same “compute close to data” slogan; still SQL-shaped; still you write the pipeline. Pixeltable’s version of that slogan is a typed table plus computed columns—the engine owns the work when a row lands. See who owns the multimodal data plane.
HTTP Handler vs Computed Column#
| Capability | Neon Functions (beta) | Pixeltable |
|---|---|---|
| Unit of work | fetch(request) → Response | Computed column / iterator view |
| When compute runs | On HTTP invoke | On insert / source change |
| Data types | Postgres rows + env creds to files/models | Video / Image / Audio / Document |
| Incremental derived columns | You write it (or Inngest) | Engine; only new or changed rows |
| Embedding / similarity | DIY in the handler | add_embedding_index + .similarity() |
| Branch / preview isolation | Neon branch_id copies function + DB | Table history / snapshots—not Neon copy-on-write |
| WebSockets / SSE | First-class isolate | Not that product; optional FastAPIRouter for HTTP |
Local pip install loop | Neon project / neon deploy | Yes |
Same Pitch, Both Ways#
Neon’s demo shape is a handler that reads Postgres (their published hello-world):
That is a fast SELECT version(). Their fuller pitch—read a row, pull an attachment from Object Storage, stream a model through AI Gateway—is still three calls you orchestrate inside fetch. New files do not chunk themselves. Indexes do not catch up unless the handler runs again.
Pixeltable starts at insert. Documents (or video) are types; splitters and indexes are columns:
No HTTPS invoke. New PDFs only split and embed new rows. Swap video for documents and the same pattern is frame_iterator + YOLOX—see the video intelligence pipeline. Serving HTTP from the catalog, if you need it, is FastAPIRouter—optional, not the engine.
Triggers “Coming Soon”#
Neon’s roadmap—native cron while the database sleeps, then object created/deleted, then auth and platform events—is the admission that request-only compute is not a pipeline. Pixeltable already treats insert as the trigger. Change a model and only affected cells recompute. That is the incremental cost model, not an external scheduler glued to fetch.
When to Use Pixeltable#
Use Pixeltable to build search, VideoRAG, agents with media memory, or training-set curation: typed media, iterators, computed model columns, embedding indexes, local Python loop. If Postgres OLTP already lives somewhere, leave it. Do not start the AI graph in fetch().
FAQ#
Is a function next to Postgres a multimodal table?#
No. It is an HTTP handler with a connection string. A multimodal data table has typed media columns, computed transforms, and indexes on the same schema.
Does Pixeltable replace Neon?#
No. Pixeltable does not copy Neon branches, host WebSockets, or inject DATABASE_URL. It owns the insert → derive → search graph for video, images, audio, and documents.
Do computed columns need an HTTP call?#
No. They run when you insert or when a source column changes. You can expose queries over HTTP later; that is serving, not orchestration.
Can files stay in object storage?#
Yes. Pixeltable media columns accept local paths, s3://, and HTTPS URLs. The catalog stores typed pointers, not gigabytes of video in a row store. Same idea as not stuffing blobs into a generic FILE column.
Get Started#
- Install:
pip install pixeltable - Docs: Quick start · Computed columns
- Tutorial: Video intelligence pipeline
