---
title: "Neon Functions vs Pixeltable Computed Columns"
date: "2026-08-18"
author: "Pierre Brunelle"
tags:
  - Neon
  - Serverless Functions
  - Computed Columns
  - Multimodal AI
  - Postgres
  - Pixeltable
  - Incremental Computation
  - Agents
description: "Neon Functions put Node.js next to Postgres. An HTTP handler is not a multimodal table. Pixeltable computed columns run on insert—video, frames, embeddings."
url: "https://pixeltable.com/blog/neon-functions-vs-pixeltable-computed-columns"
---

# Neon Functions vs Pixeltable Computed Columns

**Summary:** On August 12, 2026, Neon announced [Functions](https://neon.com/blog/neon-functions-backend-logic-next-to-your-data): 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](/blog/what-is-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 in `process.env`.

 - Isolates stay up across requests, so you keep a module-scope `pg` Pool 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](/blog/pg-durable-compute-close-to-data-multimodal-pixeltable) 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](/blog/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 | EmbeddingIndex + .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):

 
```typescript

import { Hono } from 'hono';
import { Pool } from 'pg';
const pool = new Pool({ connectionString: process.env.DATABASE_URL, max: 5 });
const app = new Hono();
app.get('/', async (c) => {
 const { rows } = await pool.query('SELECT version()');
 return c.json(rows[0]);
});
export default app;
 
```

 
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:

 
```python

import pixeltable as pxt
from pixeltable.functions.document import document_splitter
from pixeltable.functions.huggingface import sentence_transformer

TableModel = pxt.model_base()
text_embed = sentence_transformer.using(model_id='intfloat/e5-large-v2')

class Docs(TableModel, name='docs'):
 document: pxt.Document
 title: pxt.String

class Chunks(
 TableModel,
 name='chunks',
 base=Docs,
 iterator=document_splitter(
 document=Docs.document, separators='token_limit', limit=300
 ),
):
 __indexes__ = [
 pxt.EmbeddingIndex(text, string_embed=text_embed),
 ]

Docs.insert([{'document': 's3://inbox/brief.pdf', 'title': 'Q3 brief'}])

sim = Chunks.text.similarity(string='what changed in the contract')
Chunks.order_by(sim, asc=False).limit(5).collect()
 
```

 
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](/blog/video-intelligence-pipeline-tutorial). Serving HTTP from the catalog, if you need it, is [`FastAPIRouter`](/blog/schema-driven-infrastructure-ai)—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](/blog/economics-of-incremental-ai), 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](/blog/what-is-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](/blog/databricks-file-type-vs-pixeltable-media-columns).

 
## Get Started

 

 - Install: `pip install pixeltable`

 - Docs: [Quick start](https://docs.pixeltable.com/overview/quick-start) · [Computed columns](https://docs.pixeltable.com/tutorials/computed-columns)

 - Tutorial: [Video intelligence pipeline](/blog/video-intelligence-pipeline-tutorial)

 

 
## See Also

 

 - [Compute close to data: Microsoft pg_durable](/blog/pg-durable-compute-close-to-data-multimodal-pixeltable)

 - [Databricks FILE vs Pixeltable media columns](/blog/databricks-file-type-vs-pixeltable-media-columns)

 - [What is a multimodal data table?](/blog/what-is-a-multimodal-data-table)

 - [The AI Frankenstein stack](/blog/deconstructing-ai-frankenstein-stack)

 - [Schema-driven infrastructure and FastAPIRouter](/blog/schema-driven-infrastructure-ai)

 - [Video intelligence pipeline](/blog/video-intelligence-pipeline-tutorial)

 - [Who owns the multimodal data plane](/blog/who-owns-the-multimodal-data-plane)

 - [Economics of incremental AI](/blog/economics-of-incremental-ai)