---
title: Lakefront
description: An HTAP engine on DuckLake for point writes and analytical queries, without a separate ETL pipeline.
---

_Lakefront property for your lakehouse._

Lakefront is an HTAP (hybrid transactional/analytical processing) engine for TypeScript on Bun. Writes commit to a Postgres WAL; DuckDB replicas serve SQL queries, and a background flusher moves committed records into DuckLake. A board is a user-defined table, created on its first write or declared up front.

Point writes and analytical queries run in one system without a separate ETL pipeline. The [performance page](/concepts/performance) compares transactional throughput and latency with Postgres and analytical query times with native DuckDB.

```ts
import { open } from "lakefront";

await using engine = await open({
  postgres: "postgres://lakefront:lakefront@127.0.0.1:5432/lakefront",
  data: "./data",
});

await engine.insert("tasks", { id: "t1", title: "Ship it", status: "open" });
const read = await engine.query("tasks", "SELECT id, title FROM {{table}}");
```

## The primitives

These five terms describe how data is written, queried, and tracked.

| Primitive      | What it is                                                                                                                                                                                          |
| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Board**      | A user-defined table, created on first write or declared with [`createBoard`](/guides/schema). Columns are inferred from data or declared up front. The unit of caching, routing, and isolation.    |
| **Watermark**  | A monotonic position in a board's history. Every write returns the watermark it committed at; hand it back to a read and the read is at least that fresh. See [consistency](/concepts/consistency). |
| **Write path** | Where a write is durable when it acks. The default (`"wal"`) commits to a write-ahead log in the catalog Postgres. See [write paths](/concepts/write-paths).                                        |
| **Replica**    | A per-board DuckDB file that serves reads, synced to the write history before each query. A cache, never truth: delete it and it rebuilds. See [replicas](/concepts/replicas).                      |
| **Watch**      | The change feed as an async iterable: replay from a watermark, then follow live. The same surface embedded and over HTTP. See [watch](/guides/watch).                                               |

## Where to go

<CardGroup cols={2}>
  <Card title="Quickstart" href="/guides/quickstart">
    Install, start the catalog, write and read your first board.
  </Card>
  <Card title="Tutorial" href="/guides/tutorial">
    Schema evolution, transactions, watch, and the HTTP client.
  </Card>
  <Card title="Concepts" href="/concepts">
    Write paths, consistency, routing, and the design decisions behind them.
  </Card>
  <Card title="Reference" href="/reference">
    Exact APIs: OpenOptions, the wire protocol, environment variables, errors.
  </Card>
</CardGroup>

## When it fits

- **Many small, dynamic tables.** A board per tenant, team, or project, each taking point writes and serving aggregate queries.
- **Analytics on recent writes.** Reads run SQL on a replica synced before every query. Pass a write's watermark to require that the query sees it.
- **No separate ETL pipeline.** The engine propagates committed writes to its query replicas and lake storage.

## When it does not

- **One enormous table.** Nothing here shards a single huge table; the unit of everything is the board.
- **Write-heavy concurrent OLTP.** Postgres had higher write throughput in the published benchmarks.
- **A drop-in Postgres replacement.** No cross-board joins in the lake, no full SQL on the write path, no wire compatibility.
- **Node runtimes.** The package ships TypeScript source and requires Bun 1.2 or later.

Lakefront is pre-1.0. The wire format, the `OpenOptions` surface, and the write-path contract can still change between versions without a deprecation cycle.