From 844539104eca4da68d6222b464f818f7af386fbf Mon Sep 17 00:00:00 2001 From: Christiaan Landman Date: Thu, 15 Oct 2026 18:03:23 +0200 Subject: [PATCH 1/5] Neon Realtime entry. --- docs.json | 1 + integrations/neon.mdx | 4 + resources/powersync-vs-neon-realtime.mdx | 115 +++++++++++++++++++++++ 3 files changed, 120 insertions(+) create mode 100644 resources/powersync-vs-neon-realtime.mdx diff --git a/docs.json b/docs.json index 35fcf5a0b..20c8e8874 100644 --- a/docs.json +++ b/docs.json @@ -557,6 +557,7 @@ "resources/feature-status", "resources/faq", "resources/local-first-software", + "resources/powersync-vs-neon-realtime", { "group": "Security & HIPAA", "pages": ["resources/security", "resources/hipaa"] diff --git a/integrations/neon.mdx b/integrations/neon.mdx index a7da56d43..2cb686bf6 100644 --- a/integrations/neon.mdx +++ b/integrations/neon.mdx @@ -12,6 +12,10 @@ import NeonConnection from '/snippets/neon-database-connection.mdx'; This guide provides instructions for how to configure PowerSync for use with your [Neon](https://neon.tech/) project using a TypeScript demo app. + + Comparing PowerSync with Neon Realtime? See [PowerSync vs Neon Realtime](/resources/powersync-vs-neon-realtime). + + Before you proceed, this guide assumes that you have already signed up for free accounts with both Neon and PowerSync Cloud (our cloud-hosted offering). If you haven't signed up for a **PowerSync** (Cloud) account yet, [click here](https://accounts.powersync.com/portal/powersync-signup?s=docs) (and if you haven't signed up for Neon yet, [do so now](https://console.neon.tech/signup)). diff --git a/resources/powersync-vs-neon-realtime.mdx b/resources/powersync-vs-neon-realtime.mdx new file mode 100644 index 000000000..bee229215 --- /dev/null +++ b/resources/powersync-vs-neon-realtime.mdx @@ -0,0 +1,115 @@ +--- +title: "PowerSync vs Neon Realtime" +description: "A side-by-side look at PowerSync and Neon Realtime: where data lives, how writes and offline work, and what each supports." +sidebarTitle: "PowerSync vs Neon Realtime" +--- + +[Neon Realtime](https://neon.com/docs/realtime/overview) lets your app subscribe to a SQL query on Neon Postgres and get updates as the data changes. Neon launched it in public beta in October 2026. It was built by the team behind Electric, who joined Neon in August 2026. + +PowerSync syncs data from your backend database into a SQLite database inside your app. The app reads and writes that local database directly, so it responds instantly and keeps working without a network connection. PowerSync syncs changes in both directions when the app is connected. PowerSync also [supports Neon as a source database](/integrations/neon), so you can use it with an existing Neon project. + + + This comparison reflects both products as of October 2026. Neon Realtime is in beta and is changing quickly. Check [Neon's documentation](https://neon.com/docs/realtime/overview) for its current status. + + +## At a Glance + +| | **PowerSync** | **Neon Realtime** | +| --- | --- | --- | +| Status | Generally available. Some SDKs and connectors are in beta or alpha. See [Feature Status](/resources/feature-status). | Public beta | +| What the client holds | A persistent SQLite database with the synced tables | The results of each subscribed query, held in memory | +| Source databases | Postgres, MongoDB, MySQL, SQL Server, Azure DocumentDB, and Convex | Neon Postgres | +| Client SDKs | JavaScript (web, React Native, Node.js), Dart/Flutter, Kotlin, Swift, .NET, and Rust | TypeScript (browser and server), with React bindings | +| Offline support | Built in: local reads, local writes, and a persistent upload queue | Offline persistence through TanStack DB | +| Writes | Written to local SQLite, then uploaded to your backend from a queue | Sent to your backend API, with optimistic UI state until the write syncs back | +| What you sync or subscribe to | Rows selected by Sync Streams | Any read-only, deterministic SQL query, including joins and aggregates | +| TanStack DB | Optional integration (alpha) | Optional integration | +| Read permissions | Sync Streams with claims from your auth provider's JWT | Your backend authorizes and seals each query | +| Deployment | PowerSync Cloud or self-hosted | Managed by Neon | + +## How Data Is Stored on the Client + +PowerSync keeps a SQLite database on the device. Sync Streams define which rows each user receives, and the client SDK writes them into local tables. Your app queries those tables with normal SQLite, including joins, aggregates, and sorting. The data stays on the device across app restarts, and after a reconnect PowerSync normally downloads only the changes since the last sync. + +Neon Realtime works differently: there is no local database. It keeps the result of each live query in memory. Your app subscribes to a query, receives the full result, and then receives updates as transactions commit. If the connection drops, the app keeps showing the last result. When the connection returns, the subscription loads the query result again. + +They also differ in what you can query on the server: + +- Neon live queries can use almost any read-only Postgres query, including joins, aggregates, `GROUP BY`, `ORDER BY`, `LIMIT`, and window functions. Queries can't call non-deterministic functions such as `now()`. +- PowerSync [Sync Streams](/sync/streams/overview) select the rows to sync, with support for filters, subqueries, and some joins. They don't support aggregation, sorting, or `LIMIT` on the server. Instead, you run those queries against the local SQLite database after the rows are synced. + +## How Writes Work + +Neither product writes directly to your database from the client. In both cases your backend receives the write, validates it, and commits it. Your backend also decides how to handle conflicts. + +Where they differ is what happens to a write before your backend accepts it: + +| Step | **PowerSync** | **Neon Realtime** | +| --- | --- | --- | +| 1. User makes a change | The app writes to local SQLite. The change shows in the UI immediately. | The app shows the change as optimistic UI state, for example with React's `useOptimistic` or TanStack DB. | +| 2. Pending write | The client SDK stores the write in a persistent upload queue. | The pending write exists only in the app's UI state, unless you add a queue. | +| 3. Send to the server | Your upload function sends queued writes to your backend API. | Your app calls your backend API. | +| 4. Confirmation | The committed change syncs back down and replaces the local version. | Your API returns the Postgres transaction ID. The app waits for that transaction to arrive on the live query, then drops the optimistic state. | +| If the request fails | The write stays in the queue and the client SDK retries it. If your backend rejects a write permanently, your upload function must handle the error so the queue can continue. | The optimistic change rolls back, and your app decides whether to retry. | + +## Offline Support + +PowerSync is built for offline use. Users can read synced data and make changes without a connection. The changes wait in the upload queue, which survives app restarts, and upload when the device reconnects. See [Client Architecture](/architecture/client-architecture) for details. + +With Neon Realtime, live query results stay available while the app is open, even if the connection drops. For offline persistence, Neon's documentation points to [TanStack DB](https://tanstack.com/db), which has its own persistence and offline write packages. + +## TanStack DB + +Both products work with [TanStack DB](https://tanstack.com/db), and neither requires it. + +- **PowerSync:** Collections read from the local SQLite database. They can load data eagerly or on demand. The integration is in alpha. See [TanStack Query & TanStack DB](/client-sdks/frameworks/tanstack). +- **Neon Realtime:** Each collection is backed by one live query. TanStack DB manages optimistic state for writes while your backend commits them. + +## Auth and Permissions + +PowerSync clients connect with a JWT, either from your auth provider or issued by your backend. [Sync Streams](/sync/streams/overview) use claims from the token, such as the user ID, to decide which rows each user receives. Your backend authorizes writes when it receives them from the upload queue. See [Authentication](/configuration/auth/overview). + +Neon Realtime puts read authorization in your backend instead. When the app needs data, your backend authenticates the user, builds the SQL query with the user's parameters, and seals it into a short-lived token. The client uses that token to subscribe and cannot read or change the query inside it. Your backend can use any authentication method. Neon Realtime does not support Postgres row-level security (RLS) yet. Neon says it aims to add RLS before general availability. + +## Source Databases + +Maturity labels for PowerSync come from [Feature Status](/resources/feature-status). + +| Source database | **PowerSync** | **Neon Realtime** | +| --- | --- | --- | +| Postgres (including Neon) | GA | Neon Postgres only | +| MongoDB | GA | — | +| MySQL | Beta | — | +| SQL Server (including Azure SQL Database) | Beta | — | +| Azure DocumentDB | Alpha | — | +| Convex | Experimental | — | + +## Client SDKs and Platforms + +PowerSync maturity labels come from [Feature Status](/resources/feature-status). See [Supported Platforms](/resources/supported-platforms) for minimum versions and platform details. + +| SDK | **PowerSync** | **Neon Realtime** | +| --- | --- | --- | +| React Native and Expo | GA | — | +| JavaScript/TypeScript (web) | GA | Beta (browser) | +| React | GA (React hooks) | Beta (React bindings) | +| Capacitor | Beta | — | +| Tauri | Alpha | — | +| Node.js | GA | Beta (server) | +| Dart/Flutter | GA | — | +| Kotlin (Android, iOS, JVM) | GA | — | +| Swift (iOS, macOS) | GA | — | +| .NET | Beta | — | +| Rust | Beta | — | + +On the backend, Neon Realtime also provides adapters for defining queries with Drizzle and Kysely. PowerSync supports Drizzle and Kysely on the client, along with other ORMs. + +## Deployment + +You can use PowerSync Cloud or [self-host](/intro/self-hosting) the PowerSync Service. Neon Realtime runs only inside Neon. You enable it per Neon branch, and it works with branching and scale-to-zero. During the beta, it is available in four AWS regions and the Realtime service is free, but Neon still bills for database compute and data transfer. + +## Learn More + +- [Neon + PowerSync](/integrations/neon): set up PowerSync with a Neon database +- [Feature Status](/resources/feature-status) and [Supported Platforms](/resources/supported-platforms) +- [Neon Realtime documentation](https://neon.com/docs/realtime/overview) From 3d83cf53fc5f75c93cf3a0bd789897004ecb1078 Mon Sep 17 00:00:00 2001 From: Christiaan Landman Date: Fri, 16 Oct 2026 09:38:34 +0200 Subject: [PATCH 2/5] self-host and open source entries. --- resources/powersync-vs-neon-realtime.mdx | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/resources/powersync-vs-neon-realtime.mdx b/resources/powersync-vs-neon-realtime.mdx index bee229215..e2a0ae9ee 100644 --- a/resources/powersync-vs-neon-realtime.mdx +++ b/resources/powersync-vs-neon-realtime.mdx @@ -25,7 +25,9 @@ PowerSync syncs data from your backend database into a SQLite database inside yo | What you sync or subscribe to | Rows selected by Sync Streams | Any read-only, deterministic SQL query, including joins and aggregates | | TanStack DB | Optional integration (alpha) | Optional integration | | Read permissions | Sync Streams with claims from your auth provider's JWT | Your backend authorizes and seals each query | -| Deployment | PowerSync Cloud or self-hosted | Managed by Neon | +| Managed cloud | PowerSync Cloud | Neon (four AWS regions during the beta) | +| Self-hosting | Yes | No | +| Open source | Client SDKs are open source. The PowerSync Service is source-available. | Client SDK is open source. The Realtime service is not. | ## How Data Is Stored on the Client @@ -104,9 +106,20 @@ PowerSync maturity labels come from [Feature Status](/resources/feature-status). On the backend, Neon Realtime also provides adapters for defining queries with Drizzle and Kysely. PowerSync supports Drizzle and Kysely on the client, along with other ORMs. -## Deployment +## Hosting and Open Source -You can use PowerSync Cloud or [self-host](/intro/self-hosting) the PowerSync Service. Neon Realtime runs only inside Neon. You enable it per Neon branch, and it works with branching and scale-to-zero. During the beta, it is available in four AWS regions and the Realtime service is free, but Neon still bills for database compute and data transfer. +| | **PowerSync** | **Neon Realtime** | +| --- | --- | --- | +| Managed cloud | PowerSync Cloud | Runs inside Neon. Available in four AWS regions during the beta. | +| Self-hosting | Yes. The [Open Edition](/intro/self-hosting) is free to self-host, and an Enterprise Self-Hosted Edition is available. | No. Realtime runs only on Neon's platform. | +| Client SDKs | Open source (Apache 2.0, except the Kotlin SDK, which is MIT) | Open source (Apache 2.0) | +| Sync service | Source-available under FSL-1.1-ALv2. Each release becomes Apache 2.0 after two years. | Not open source. Neon has not published the source code of the live query engine or the Live SQL API. | + + + You can't self-host Neon Realtime. If you need to run sync on your own infrastructure, for example for data residency or compliance, PowerSync supports that with the Open Edition or the Enterprise Self-Hosted Edition. + + +You enable Neon Realtime per Neon branch, and it works with Neon branching and scale-to-zero. The Realtime service is free during the beta, but Neon still bills for database compute and data transfer. ## Learn More From c3a038d17d71a1c03131c5568dd440578ef1881a Mon Sep 17 00:00:00 2001 From: Conrad Hofmeyr Date: Tue, 20 Oct 2026 16:26:43 -0500 Subject: [PATCH 3/5] Minor edits --- resources/powersync-vs-neon-realtime.mdx | 44 ++++++++++++------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/resources/powersync-vs-neon-realtime.mdx b/resources/powersync-vs-neon-realtime.mdx index e2a0ae9ee..06c0ce071 100644 --- a/resources/powersync-vs-neon-realtime.mdx +++ b/resources/powersync-vs-neon-realtime.mdx @@ -4,12 +4,12 @@ description: "A side-by-side look at PowerSync and Neon Realtime: where data liv sidebarTitle: "PowerSync vs Neon Realtime" --- -[Neon Realtime](https://neon.com/docs/realtime/overview) lets your app subscribe to a SQL query on Neon Postgres and get updates as the data changes. Neon launched it in public beta in October 2026. It was built by the team behind Electric, who joined Neon in August 2026. +[Neon Realtime](https://neon.com/docs/realtime/overview) lets your app subscribe to a SQL query on Neon Postgres and get updates as the data changes. Neon [launched it](https://neon.com/blog/neon-now-has-realtime) in public beta in October 2026. It was built by the team behind [Electric](https://electric.ax/), who joined Neon in August 2026. PowerSync syncs data from your backend database into a SQLite database inside your app. The app reads and writes that local database directly, so it responds instantly and keeps working without a network connection. PowerSync syncs changes in both directions when the app is connected. PowerSync also [supports Neon as a source database](/integrations/neon), so you can use it with an existing Neon project. - This comparison reflects both products as of October 2026. Neon Realtime is in beta and is changing quickly. Check [Neon's documentation](https://neon.com/docs/realtime/overview) for its current status. + This comparison reflects both products as of October 2026. Neon Realtime is in beta and is changing quickly. Check the [Neon Realtime docs](https://neon.com/docs/realtime/overview) for its current status. ## At a Glance @@ -19,10 +19,10 @@ PowerSync syncs data from your backend database into a SQLite database inside yo | Status | Generally available. Some SDKs and connectors are in beta or alpha. See [Feature Status](/resources/feature-status). | Public beta | | What the client holds | A persistent SQLite database with the synced tables | The results of each subscribed query, held in memory | | Source databases | Postgres, MongoDB, MySQL, SQL Server, Azure DocumentDB, and Convex | Neon Postgres | -| Client SDKs | JavaScript (web, React Native, Node.js), Dart/Flutter, Kotlin, Swift, .NET, and Rust | TypeScript (browser and server), with React bindings | -| Offline support | Built in: local reads, local writes, and a persistent upload queue | Offline persistence through TanStack DB | +| Client SDKs | JavaScript (web, React Native, Node.js, Tauri, Capacitor), Dart/Flutter, Kotlin, Swift, .NET, and Rust | TypeScript (browser and server), with React bindings | +| Offline support | Built in: local reads, local writes, and a persistent upload queue | Offline persistence through [TanStack DB](https://tanstack.com/db) | | Writes | Written to local SQLite, then uploaded to your backend from a queue | Sent to your backend API, with optimistic UI state until the write syncs back | -| What you sync or subscribe to | Rows selected by Sync Streams | Any read-only, deterministic SQL query, including joins and aggregates | +| What you sync or subscribe to | Rows selected by queries in Sync Streams | Any read-only, deterministic SQL query, including joins and aggregates | | TanStack DB | Optional integration (alpha) | Optional integration | | Read permissions | Sync Streams with claims from your auth provider's JWT | Your backend authorizes and seals each query | | Managed cloud | PowerSync Cloud | Neon (four AWS regions during the beta) | @@ -31,32 +31,32 @@ PowerSync syncs data from your backend database into a SQLite database inside yo ## How Data Is Stored on the Client -PowerSync keeps a SQLite database on the device. Sync Streams define which rows each user receives, and the client SDK writes them into local tables. Your app queries those tables with normal SQLite, including joins, aggregates, and sorting. The data stays on the device across app restarts, and after a reconnect PowerSync normally downloads only the changes since the last sync. +PowerSync maintains a SQLite database on the client. Sync Streams define which rows each client receives, and the PowerSync client SDK writes them into SQLite tables. Your app queries those tables with normal SQLite queries, including joins, aggregates, and sorting. The data persists on the client across app restarts, and after a reconnect, PowerSync normally downloads only the deltas since the last sync. -Neon Realtime works differently: there is no local database. It keeps the result of each live query in memory. Your app subscribes to a query, receives the full result, and then receives updates as transactions commit. If the connection drops, the app keeps showing the last result. When the connection returns, the subscription loads the query result again. +Neon Realtime works differently: there is no client-side database. It keeps the result of each live query in memory. Your app subscribes to a query, receives the full result, and then receives updates as transactions commit. If the connection drops, the app keeps showing the last result. When the connection returns, the subscription loads the query result again. -They also differ in what you can query on the server: +They also differ in what you can query on the source database: - Neon live queries can use almost any read-only Postgres query, including joins, aggregates, `GROUP BY`, `ORDER BY`, `LIMIT`, and window functions. Queries can't call non-deterministic functions such as `now()`. -- PowerSync [Sync Streams](/sync/streams/overview) select the rows to sync, with support for filters, subqueries, and some joins. They don't support aggregation, sorting, or `LIMIT` on the server. Instead, you run those queries against the local SQLite database after the rows are synced. +- PowerSync [Sync Streams](/sync/streams/overview) select the rows to sync, with support for filters, subqueries, and [some joins](/sync/streams/queries#using-joins). They don't support aggregation, sorting, or `LIMIT` on the server. Instead, you include those in your queries against the local SQLite database after the rows are synced. ## How Writes Work -Neither product writes directly to your database from the client. In both cases your backend receives the write, validates it, and commits it. Your backend also decides how to handle conflicts. +Neither PowerSync nor Neon Realtime writes directly to the source database from the client. With both, your backend receives a mutation, validates it, and commits it. Your backend also decides how to handle conflicts. -Where they differ is what happens to a write before your backend accepts it: +Where they differ is what happens to a mutation before your backend accepts it: | Step | **PowerSync** | **Neon Realtime** | | --- | --- | --- | | 1. User makes a change | The app writes to local SQLite. The change shows in the UI immediately. | The app shows the change as optimistic UI state, for example with React's `useOptimistic` or TanStack DB. | -| 2. Pending write | The client SDK stores the write in a persistent upload queue. | The pending write exists only in the app's UI state, unless you add a queue. | -| 3. Send to the server | Your upload function sends queued writes to your backend API. | Your app calls your backend API. | -| 4. Confirmation | The committed change syncs back down and replaces the local version. | Your API returns the Postgres transaction ID. The app waits for that transaction to arrive on the live query, then drops the optimistic state. | -| If the request fails | The write stays in the queue and the client SDK retries it. If your backend rejects a write permanently, your upload function must handle the error so the queue can continue. | The optimistic change rolls back, and your app decides whether to retry. | +| 2. Pending mutation | The client SDK stores the mutation in a persistent upload queue. | The pending mutation exists only in the app's UI state, unless you add a queue. | +| 3. Send to the server | Your upload function sends queued mutation to your backend API. | Your app calls your backend API. | +| 4. Confirmation | The committed change syncs back down and replaces the client-side version. | Your API returns the Postgres transaction ID. The app waits for that transaction to arrive on the live query, then drops the optimistic state. | +| If the request fails | The mutation stays in the queue and the client SDK retries it. If your backend rejects a mutation permanently, your upload function must handle the error so the queue can continue. | The optimistic change rolls back, and your app decides whether to retry. | ## Offline Support -PowerSync is built for offline use. Users can read synced data and make changes without a connection. The changes wait in the upload queue, which survives app restarts, and upload when the device reconnects. See [Client Architecture](/architecture/client-architecture) for details. +PowerSync is built for offline use. Users can read synced data and make changes without a connection. The mutations wait in the upload queue, which survives app restarts, and upload when the client reconnects. See [Client Architecture](/architecture/client-architecture) for details. With Neon Realtime, live query results stay available while the app is open, even if the connection drops. For offline persistence, Neon's documentation points to [TanStack DB](https://tanstack.com/db), which has its own persistence and offline write packages. @@ -64,18 +64,18 @@ With Neon Realtime, live query results stay available while the app is open, eve Both products work with [TanStack DB](https://tanstack.com/db), and neither requires it. -- **PowerSync:** Collections read from the local SQLite database. They can load data eagerly or on demand. The integration is in alpha. See [TanStack Query & TanStack DB](/client-sdks/frameworks/tanstack). +- **PowerSync:** Collections read from the local SQLite database. They can load data eagerly or on demand. The integration is in alpha. See [docs](/client-sdks/frameworks/tanstack). - **Neon Realtime:** Each collection is backed by one live query. TanStack DB manages optimistic state for writes while your backend commits them. ## Auth and Permissions -PowerSync clients connect with a JWT, either from your auth provider or issued by your backend. [Sync Streams](/sync/streams/overview) use claims from the token, such as the user ID, to decide which rows each user receives. Your backend authorizes writes when it receives them from the upload queue. See [Authentication](/configuration/auth/overview). +PowerSync clients connect with a JWT, either from your auth provider or issued by your backend. [Sync Streams](/sync/streams/overview) use claims from the token, such as the user ID, to decide which rows each client receives. Your backend authorizes writes when it receives them from the upload queue. See [Authentication](/configuration/auth/overview). -Neon Realtime puts read authorization in your backend instead. When the app needs data, your backend authenticates the user, builds the SQL query with the user's parameters, and seals it into a short-lived token. The client uses that token to subscribe and cannot read or change the query inside it. Your backend can use any authentication method. Neon Realtime does not support Postgres row-level security (RLS) yet. Neon says it aims to add RLS before general availability. +Neon Realtime puts read authorization in your backend instead. When the app needs data, your backend authenticates the user, builds the SQL query with the user's parameters, and seals it into a short-lived token. The client uses that token to subscribe and cannot read or change the query inside it. Your backend can use any authentication method. Neon Realtime does not support Postgres row-level security (RLS) yet. Neon [says](https://neon.com/docs/realtime/guides/queries#why-not-row-level-security) it aims to add RLS before general availability. ## Source Databases -Maturity labels for PowerSync come from [Feature Status](/resources/feature-status). +Maturity labels for PowerSync as documented in [Feature Status](/resources/feature-status). | Source database | **PowerSync** | **Neon Realtime** | | --- | --- | --- | @@ -88,7 +88,7 @@ Maturity labels for PowerSync come from [Feature Status](/resources/feature-stat ## Client SDKs and Platforms -PowerSync maturity labels come from [Feature Status](/resources/feature-status). See [Supported Platforms](/resources/supported-platforms) for minimum versions and platform details. +PowerSync maturity labels as documented in [Feature Status](/resources/feature-status). See [Supported Platforms](/resources/supported-platforms) for minimum versions and platform details. | SDK | **PowerSync** | **Neon Realtime** | | --- | --- | --- | @@ -112,7 +112,7 @@ On the backend, Neon Realtime also provides adapters for defining queries with D | --- | --- | --- | | Managed cloud | PowerSync Cloud | Runs inside Neon. Available in four AWS regions during the beta. | | Self-hosting | Yes. The [Open Edition](/intro/self-hosting) is free to self-host, and an Enterprise Self-Hosted Edition is available. | No. Realtime runs only on Neon's platform. | -| Client SDKs | Open source (Apache 2.0, except the Kotlin SDK, which is MIT) | Open source (Apache 2.0) | +| Client SDKs | Open source (Apache 2.0) | Open source (Apache 2.0) | | Sync service | Source-available under FSL-1.1-ALv2. Each release becomes Apache 2.0 after two years. | Not open source. Neon has not published the source code of the live query engine or the Live SQL API. | From 451461baf03d1442d0bca8ad3559be1510165cbc Mon Sep 17 00:00:00 2001 From: Christiaan Landman Date: Wed, 21 Oct 2026 12:16:48 +0200 Subject: [PATCH 4/5] Moved to alternatives section and added index page. --- docs.json | 8 +++++++- integrations/neon.mdx | 2 +- .../neon-realtime.mdx} | 0 resources/alternatives/overview.mdx | 20 +++++++++++++++++++ 4 files changed, 28 insertions(+), 2 deletions(-) rename resources/{powersync-vs-neon-realtime.mdx => alternatives/neon-realtime.mdx} (100%) create mode 100644 resources/alternatives/overview.mdx diff --git a/docs.json b/docs.json index 20c8e8874..2c52e444c 100644 --- a/docs.json +++ b/docs.json @@ -557,7 +557,13 @@ "resources/feature-status", "resources/faq", "resources/local-first-software", - "resources/powersync-vs-neon-realtime", + { + "group": "Alternatives", + "pages": [ + "resources/alternatives/overview", + "resources/alternatives/neon-realtime" + ] + }, { "group": "Security & HIPAA", "pages": ["resources/security", "resources/hipaa"] diff --git a/integrations/neon.mdx b/integrations/neon.mdx index 2cb686bf6..6992f4223 100644 --- a/integrations/neon.mdx +++ b/integrations/neon.mdx @@ -13,7 +13,7 @@ import NeonConnection from '/snippets/neon-database-connection.mdx'; This guide provides instructions for how to configure PowerSync for use with your [Neon](https://neon.tech/) project using a TypeScript demo app. - Comparing PowerSync with Neon Realtime? See [PowerSync vs Neon Realtime](/resources/powersync-vs-neon-realtime). + Comparing PowerSync with Neon Realtime? See [PowerSync vs Neon Realtime](/resources/alternatives/neon-realtime). diff --git a/resources/powersync-vs-neon-realtime.mdx b/resources/alternatives/neon-realtime.mdx similarity index 100% rename from resources/powersync-vs-neon-realtime.mdx rename to resources/alternatives/neon-realtime.mdx diff --git a/resources/alternatives/overview.mdx b/resources/alternatives/overview.mdx new file mode 100644 index 000000000..844d75ebe --- /dev/null +++ b/resources/alternatives/overview.mdx @@ -0,0 +1,20 @@ +--- +title: "Alternatives Overview" +description: "Compare PowerSync with other sync and realtime products, and find migration guides for moving to PowerSync." +sidebarTitle: "Overview" +--- + +These pages compare PowerSync with other products that sync or stream database changes to apps. Each comparison covers where data lives on the client, how writes and offline work, auth, source databases, supported platforms, and hosting. + + + + Live SQL queries on Neon Postgres, compared with PowerSync's local SQLite sync. + + + +## Migrating to PowerSync + +If you already use another sync product, these guides compare it with PowerSync and walk through the move: + +- [Electric Cloud](/migration-guides/electric) +- [MongoDB Atlas Device Sync](/migration-guides/atlas-device-sync) From 0683eb341d577d0659ff0590d54e29f1a8ccc00a Mon Sep 17 00:00:00 2001 From: Conrad Hofmeyr Date: Wed, 21 Oct 2026 11:07:48 -0500 Subject: [PATCH 5/5] Edits to Alternatives index page --- resources/alternatives/overview.mdx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/resources/alternatives/overview.mdx b/resources/alternatives/overview.mdx index 844d75ebe..6a54b6809 100644 --- a/resources/alternatives/overview.mdx +++ b/resources/alternatives/overview.mdx @@ -1,10 +1,10 @@ --- title: "Alternatives Overview" -description: "Compare PowerSync with other sync and realtime products, and find migration guides for moving to PowerSync." +description: "Compare PowerSync with other sync engines and real-time data infrastructure products, and find migration guides for moving to PowerSync." sidebarTitle: "Overview" --- -These pages compare PowerSync with other products that sync or stream database changes to apps. Each comparison covers where data lives on the client, how writes and offline work, auth, source databases, supported platforms, and hosting. +These pages compare PowerSync with other products that sync or stream database changes to apps. @@ -14,7 +14,7 @@ These pages compare PowerSync with other products that sync or stream database c ## Migrating to PowerSync -If you already use another sync product, these guides compare it with PowerSync and walk through the move: +If you already use another sync product, these guides walk through migrating to PowerSync: - [Electric Cloud](/migration-guides/electric) - [MongoDB Atlas Device Sync](/migration-guides/atlas-device-sync)