electric-sql
/electric-sql
Build local-first applications with ElectricSQL — sync Postgres data to client devices in real-time. Use when someone asks to "sync database to client", "local-first app", "ElectricSQL", "offline-first sync", "real-time Postgres sync", "sync Postgres to SQLite", or "build an app that works offline". Covers shape-based sync, real-time subscriptions, offline support, and conflict resolution.
- Author
- TerminalSkills ↗
- Repository
- skills ↗
- Licence
- Apache-2.0
- Last repository change
- 25.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 3
No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Build local-first applications with ElectricSQL — sync Postgres data to client devices in real-time. Use when someone asks to "sync database to client", "local-first app", "ElectricSQL", "offline-first sync", "real-time Postgres sync", "sync Postgres to SQLite", or "build an app that works offline". Covers shape-based sync, real-time subscriptions, offline support, and conflict resolution.
Triggers from the description
Original author description
Build local-first applications with ElectricSQL — sync Postgres data to client devices in real-time. Use when someone asks to "sync database to client", "local-first app", "ElectricSQL", "offline-first sync", "real-time Postgres sync", "sync Postgres to SQLite", or "build an app that works offline". Covers shape-based sync, real-time subscriptions, offline support, and conflict resolution.
How it works
- Overview
- When to Use
- Instructions
- Examples
- Guidelines
SKILL.md preview
---
name: electric-sql
description: >-
Build local-first applications with ElectricSQL — sync Postgres data to client
devices in real-time. Use when someone asks to "sync database to client",
"local-first app", "ElectricSQL", "offline-first sync", "real-time Postgres
sync", "sync Postgres to SQLite", or "build an app that works offline".
Covers shape-based sync, real-time subscriptions, offline support, and
conflict resolution.
license: Apache-2.0
compatibility: "PostgreSQL. Clients: React, React Native, Expo, any HTTP client."
metadata:
author: terminal-skills
version: "1.1.0"
category: data-ai
tags: "sync, local-first, offline, postgres, real-time"
repository: https://github.com/electric-sql/electric
---
# ElectricSQL
## Overview
ElectricSQL syncs Postgres data to client applications in real-time. Instead of fetching data from an API, the data lives locally on the device — queries are instant, the app works offline, and changes sync automatically when connectivity returns. Think "Postgres replication to the browser." Define shapes (subsets of your data) and Electric keeps them in sync.
## When to Use
- Apps that must work offline (field service, mobile, travel)
- Real-time collaborative features (shared lists, dashboards)
- Low-latency reads — querying local data is instant
- Reducing API calls — data is already on the client
- Multi-device sync (phone, tablet, desktop see same data)
## Instructions
### Setup
```bash
# Server: Electric sync service
docker run -e DATABASE_URL=postgresql://... -p 3000:3000 electricsql/electric
# Client
npm install @electric-sql/react
```
### Define Shapes (What to Sync)
```typescript
// shapes.ts — Define what data to sync to the client
/**
* Shapes are "live queries" — subsets of your Postgres data
* that stay in sync on the client. Only sync what the user needs.
*/
import { ShapeStream } from "@electric-sql/client";
// Sync all todos for a specific user — use a parameterized `where`
// (positional $1, $2, ... in `params.params`), never string-interpolate
// a value into the clause itself.
const stream = new ShapeStream({
url: "http://localhost:3000/v1/shape",
params: {
table: "todos",
where: "user_id = $1",
params: [userId],
},
});
// Stream delivers initial data + real-time updates
stream.subscribe((messages) => {
for (const msg of messages) {
if (msg.headers.operation === "insert") {
console.log("New todo:", msg.value);
}
}
});
```
### React Integration
```tsx
// components/TodoList.tsx — Real-time synced todo list
import { useShape } from "@electric-sql/react";
interface Todo {
id: string;
title: string;
completed: boolean;
created_at: string;
}
export function TodoList({ userId }: { userId: string }) {
// Data syncs automatically — no loading states for reads
const { data: todos, isLoading } = useShape<Todo>({
url: "http://localhost:3000/v1/shape",
params: {
table: "todos",
where: "user_id = $1",
params: [userId],
columns: ["id", "title", "completed", "created_at"],
},
});
if (isLoading) return <div>Loading initial sync...</div>;
// Reads are instant — data is local
const active = todos.filter((t) => !t.completed);
const done = todos.filter((t) => t.completed);
return (
<div>
<h2>Active ({active.length})</h2>
{active.map((todo) => (
<div key={todo.id}>
<input
type="checkbox"
onChange={() => toggleTodo(todo.id)}
/>
{todo.title}
</div>
))}
<h2>Completed ({done.length})</h2>
{done.map((todo) => (
<div key={todo.id} style={{ textDecoration: "line-through" }}>
{todo.title}
</div>
))}
</div>
);
}
// Writes go through your API (Electric syncs the result back)
async function toggleTodo(id: string) {
await fetch(`/api/todos/${id}/toggle`, { method: "PATCH" });
// No need to refetch — Electric syncs the update automatically
}
```
### Offline Support
```typescript
// offline.ts — Electric handles offline automatically
/**
* When the device goes offline, reads still work (data is local).
* When connectivity returns, Electric syncs missed changes.
*
* For writes during offline, queue them and replay on reconnect:
*/
const writeQueue: Array<() => Promise<void>> = [];
async function createTodo(title: string) {
const action = () => fetch("/api/todos", {
method: "POST",
body: JSON.stringify({ title }),
});
if (navigator.onLine) {
await action();
} else {
writeQueue.push(action); // Queue for later
}
}
// Replay queued writes when back online
window.addEventListener("online", async () => {
while (writeQueue.length > 0) {
const action = writeQueue.shift()!;
await action();
}
});
```
## Examples
### Example 1: Build an offline-capable task manager
**User prompt:** "Build a task manager that works without internet and syncs when back online."
The agent will set up Electric with shapes for user tasks, local reads with React hooks, write queue for offline mutations, and automatic sync on reconnect.
### Example 2: Real-time dashboard
**User prompt:** "Build a dashboard that shows live data from our Postgres database without polling."
The agent will configure Electric shapes for dashboard metrics, subscribe to real-time updates, and render charts that update instantly as the database changes.
## Guidelines
- **Shapes define what syncs** — sync subsets of data, not entire tables
- **Reads are instant** — data is local, no network round-trip
- **Writes go through your API** — Electric syncs the result back to all clients
- **`where` for filtering** — only sync data the user should see; pass values through the positional `params` array (`where: "user_id = $1"`, `params: [userId]`), never string-interpolate a value into the `where` clause — Electric's HTTP API parses it as SQL and an interpolated value is a SQL-injection vector
- **`columns` for projection** — reduce sync payload to needed fields
- **Postgres is the source of truth** — Electric reads the WAL (Write-Ahead Log)
- **No schema changes needed** — works with your existing Postgres schema
- **Shape streams are resumable** — reconnects sync from where they left off
- **For offline writes, queue locally** — replay when connectivity returns
- **Use with any framework** — React hook is convenient, but the core client works anywhere
Files in this package (2)
- SKILL.md 6 KB
- _scores.json 4 KB
Versions
The database has no other skills named electric-sql.
Database snapshot: 13.11.2026 · package version f33e2e25c982 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90mobile-offline-first
Use this skill when the user says 'offline-first', 'offline mode', 'offline sync', 'local storage', 'offline cache', 'sync strategy', 'conflict resolution', 'offline queue', 'mobile offline', 'local database'. Design offline-capable mobile apps with local storage, sync… - 100mobile-app-offline-first-sync
Use this skill when designing offline-resilient mobile architectures with local write buffering and cloud conflict resolution. - 100capacitor-offline-first
Designs and implements offline-first data in Capacitor apps - local SQLite source of truth with @capgo/capacitor-fast-sql (`FastSQL.connect`, `KeyValueStore`), an outbox/sync queue, delta pulls, conflict resolution, @capacitor/network `networkStatusChange`, background sync with… - 90mobile-offline-sync
Builds local-first mobile storage with an optimistic local store, durable mutation outbox, per-entity conflict-resolution rules, incremental pull, and idempotent background retry. Use when someone says "the app has to work offline", "how do I sync Room or SQLite or Realm with… - 100tinybase
TinyBase is a reactive in-memory data store for local-first JavaScript and TypeScript apps, with tables, key-value data, queries, persistence and CRDT sync. Use when a user asks to build an offline-capable or local-first app, keep app state in a TinyBase store, persist it to… - 95real-time-collaboration-engine
Build real-time collaborative editing with WebSockets, OT/CRDT conflict resolution, and presence awareness. Implements cursor tracking, optimistic updates, and offline sync. Use for collaborative editors, whiteboards, video editing. Activate on "real-time collaboration",…