diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 05fb08b4164..ecab8ed2278 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -10,6 +10,7 @@ issue_enrichment: enabled: true reviews: + high_level_summary: false # Skip machine-generated / vendored files (mirrors .prettierignore). Keeps # reviews focused on hand-written code and preserves rate-limit budget on # large codegen diffs. diff --git a/apps/docs/components/ContentListings/ContentListings.client.tsx b/apps/docs/components/ContentListings/ContentListings.client.tsx index 93086bd588a..b28e1b18841 100644 --- a/apps/docs/components/ContentListings/ContentListings.client.tsx +++ b/apps/docs/components/ContentListings/ContentListings.client.tsx @@ -29,6 +29,8 @@ function useContentListingClickHandler(group: ContentListingGroup) { const trackClick = useCallback( (item: ContentListingItem) => { + if (!item.href) return + sendTelemetryEvent({ action: 'docs_content_listing_clicked', properties: { @@ -73,8 +75,45 @@ function ContentListingsGroup({ group }: { group: ContentListingGroup }) { )}
+
+Compute runs web services and agents in any language next to your database. There's no limit on how long a service runs, you choose the memory and CPU, and each service gets a full Linux environment, which Edge Functions don't have.
+
+Deploy from the Supabase CLI, or manage services through the Management API. The service definition lives in `config.toml`, and agent skills for Compute let your coding agent write, deploy, monitor, and debug a service for you. A service gets the same default environment variables as your Edge Functions, so it connects to your database and other Supabase services. In the dashboard you see each service's runtime, invocations, and logs.
+
+Each service gets a public HTTP URL, like an Edge Function. Set the number of instances, and Supabase balances requests across them. You can also deploy a service as private, with no HTTP endpoint, for background jobs from a database queue or as a sandbox for an agent. To tighten security further, network restrictions can limit database access to your Compute instances.
+
+## Your app's MCP server
+
+
+
+MCP is the standard that lets agents talk to your app on behalf of your users. Your app's MCP server is separate from the official Supabase MCP server, which helps you build your app.
+
+Add a customizable MCP server to your own app from the [Supabase library](https://supabase.com/library). One shadcn command adds an authenticated Edge Function to your codebase, ready to deploy to Supabase. You own the code, so your agent can use the included instructions and Supabase client to add the tools that fit your product, and your RLS policies still decide which rows each user can reach.
+
+It's built on `@supabase/server` and the new Supabase Middleware, which also work on their own in any server code that needs to know who is signed in.
+
+We also built a [headless app template](https://supabase.com/library/docs/tanstack/headless-app): a backend with an agent as the main interface, ready to deploy to Supabase.
+
+## Get started
+
+- Agent-ready local development: update the [Supabase CLI](https://supabase.com/docs/guides/local-development/cli/getting-started), then add `[experimental]` and `stack = true` to `supabase/config.toml`, or set `SUPABASE_EXPERIMENTAL_STACK=1`.
+- Declarative Schemas 2.0: put your schema in `supabase/schemas/*.sql`, run `supabase db schema declarative sync` to generate and apply the migration locally, then run `supabase db push`. Existing projects: add `[experimental.pgdelta]` and `enabled = true` to `supabase/config.toml`. [Docs](https://supabase.com/docs/guides/local-development/declarative-database-schemas).
+- Supabase Compute: in private alpha. [Join the waitlist](https://supabase.com/compute).
+- Your app's MCP server: get your project into code with `supabase pull`, then run `npx shadcn@latest add @supabase/mcp-server` from the [MCP server block](https://supabase.com/library/docs/headless/mcp). It needs asymmetric signing keys and the Supabase Auth OAuth server turned on.
diff --git a/apps/www/_blog/2026-10-02-select-2026-operate-with-confidence.mdx b/apps/www/_blog/2026-10-02-select-2026-operate-with-confidence.mdx
new file mode 100644
index 00000000000..e0fae3ac57b
--- /dev/null
+++ b/apps/www/_blog/2026-10-02-select-2026-operate-with-confidence.mdx
@@ -0,0 +1,128 @@
+---
+title: 'Operate with confidence'
+description: 'More data, more tools and more control so your agent has what it needs to observe your project, investigate issues and propose fixes, autonomously.'
+author: steven_eubank, joshenlim, cemal_kilic, riccardo_busetti, joe_sciarrino
+date: '2026-10-02T10:25:00'
+categories:
+ - product
+tags:
+ - ai
+ - mcp
+ - observability
+imgSocial: 'select-2026-operate-with-confidence/og.png'
+imgThumb: 'select-2026-operate-with-confidence/thumb.png'
+toc_depth: 2
+---
+
+Today at Supabase Select, we announced new tools that let your coding agent find production problems, test fixes, and report back, and new controls that set what the agent can access and when it stops to ask you first.
+
+Diagnosing a production problem today means reading logs, usage charts, and database reports separately and correlating them yourself. Your agent could already read that data, but it had no procedure for investigating and no safe place to test a fix.
+
+For an agent to confidently operate a project:
+
+- It needs [data](#data) to observe
+- It needs [knowledge](#knowledge) on what to look for in that data
+- It needs [autonomy](#autonomy) to test and validate fixes in its own environment
+- It needs [permission](#permissions) to do only what is required
+
+## Data
+
+### query_logs
+
+Previously your agents were limited in what logs they could access via our MCP. We’ve introduced a new MCP tool that gives your agents raw access to your project logs via SQL, which enables more in-depth and precise investigations.
+
+### More advisor checks
+
+
+
+Programmatic checks can catch obvious issues and provide signal for an agent to investigate further. Advisor previously focused on security and performance checks. We’ve now extended it to health. Advisor will signal when error rates go beyond what is considered normal across Data API, Auth, Storage, and Edge Functions. Checks run on demand from the dashboard or the Management API, and results show up under a new Health tab on the Advisors page.
+
+### Database Connections
+
+
+
+See which sessions hold connections, which queries run long, which are idle in a transaction, which are blocked, and who holds the lock. You can cancel a query or terminate its connection from there. It's on by default for every project, including self-hosted.
+
+### Introducing Notebooks
+
+
+
+A notebook is a file in your supabase folder that combines saved database or log queries with markdown notes. Run Notebooks yourself or get your agents to run them as part of their ongoing observations. You can create notebooks directly in the dashboard via the Assistant, then pull them down locally as files with `supabase notebooks pull` if needed. You can also create notebooks locally (including with your own agent) and push them with `supabase notebooks push` to make them accessible in the dashboard.
+
+Notebooks can be found in the new Explorer, an evolution of the SQL editor, which is rolling out to every project through October 12. Once it reaches your project, you can turn it on under Feature Previews in the dashboard. Notebook CLI tools are available in the beta version of our CLI.
+
+## Knowledge
+
+### Updated Skills
+
+Supabase skills now point to a living document of common health, security, performance, and resource signals your agent should watch for and how to monitor those signals.
+
+```bash
+npm install supabase --save-dev
+npx plugins add supabase-community/supabase-plugin
+```
+
+## Autonomy
+
+
+
+Agents operate best in code. Today at Supabase Select we announced several improvements to how Supabase projects are expressed as code, and how that code can run in more environments. This is an important upgrade for the observing → detection → resolving loop: it lets agents test and validate proposed fixes in their own environment before opening a PR. That environment may not be your local machine.
+
+Read more about pg-delta and upgrades to the local runtime in the [Build post](https://supabase.com/blog/select-2026-build-anything).
+
+## Permissions
+
+Give your agent only the access it needs to do its job, and get alerted when it attempts a riskier action.
+
+### Enterprise-Managed Auth for MCP
+
+Your company decides who can connect to the Supabase MCP server through its identity provider, starting with Okta. Each token is short-lived and bound to the member who signed in. To cut off access, remove the app from Authorized Apps, or remove the member. This is generally available.
+
+### Scoped Personal Access Tokens
+
+Limit a token to the organizations, projects, and permissions you choose. Start with a read-only token. It's generally available and is now the default for new tokens created in the dashboard.
+
+### MCP Elicitations
+
+
+
+Before the agent creates a paid project or branch, the Supabase MCP server asks you to confirm the resource, rate, and billing interval in your agent client, then waits for your answer. It also asks for confirmation before running SQL that could delete data. This helps prevent unwanted charges and data loss, but it’s not a guarantee. Your agent client must support elicitations for the prompt to appear.
+
+## Supabase Pipelines
+
+
+
+Pipelines stream your Postgres data to analytical destinations in near real time, so heavy analytics queries don’t impact primary Postgres. Create a pipeline in the dashboard, choose the destination, and select the tables to replicate. The initial sync starts, and schema changes are detected and applied to the destination automatically. The dashboard shows each pipeline's health and the status of every replicated table.
+
+Pipelines are in public alpha on the Pro, Team, and Enterprise plans, with BigQuery, ClickHouse, DuckLake, and Snowflake as destinations.
+
+## Getting started
+
+Setting up an agent that autonomously observes your project, detects issues, and proposes fixes can be daunting, but it’s really only a prompt away with your favorite agent harness. We’ve created a few prompts and suggested schedules to set your agent up for success.
+
+- [Health](https://supabase.com/docs/guides/observability/automate-with-agents/health)
+- [Security](https://supabase.com/docs/guides/observability/automate-with-agents/security)
+- [Performance](https://supabase.com/docs/guides/observability/automate-with-agents/performance)
+- [Resources](https://supabase.com/docs/guides/observability/automate-with-agents/usage)
+- Supabase Pipelines: on a paid plan, open Database, then Pipelines in the Dashboard, add a BigQuery, ClickHouse, DuckLake, or Snowflake destination, and pick your tables. [Docs](https://supabase.com/docs/guides/database/replication/pipelines).
diff --git a/apps/www/_blog/2026-10-02-select-2026-scale-without-limits.mdx b/apps/www/_blog/2026-10-02-select-2026-scale-without-limits.mdx
new file mode 100644
index 00000000000..08ba9dcc9ed
--- /dev/null
+++ b/apps/www/_blog/2026-10-02-select-2026-scale-without-limits.mdx
@@ -0,0 +1,140 @@
+---
+title: 'Scale without limits: Multigres, OrioleDB, and dbarena'
+description: 'The app your agent built in minutes stays on the same Postgres from prototype to petabyte.'
+author: joe_sciarrino, alexander_korotkov, daniel_mitterdorfer, aditya_maruvada
+date: '2026-10-02T10:35:00'
+categories:
+ - product
+tags:
+ - postgres
+ - database
+ - scaling
+imgSocial: 'select-2026-scale-without-limits/og.png'
+imgThumb: 'select-2026-scale-without-limits/thumb.png'
+toc_depth: 2
+---
+
+Today at Supabase Select, we announced Multigres for high availability and scalable connection pooling, and OrioleDB for high performance storage. We launched dbarena, an open benchmarks site for comparing managed Postgres providers’ performance results and costs.
+
+Every Supabase project starts with a single Postgres database. As your project grows, vertically upgrading the database’s available RAM & CPU resources can help, but it isn’t a solution to every challenge.
+
+Scaling Postgres isn’t a singular problem — users encounter new challenges at different stages of scale and under different workloads. Our users often report needing help scaling concurrent client connections, reducing the overhead of bloat and frequent VACUUM operations, increasing read and write throughput, avoiding transaction ID wraparound, and guaranteeing uptime with high availability.
+
+Our focus is to remove every scaling limitation from our users’ journey. That means tackling bottlenecks at every layer of Postgres, building in public, and making the improvements fully open source and available to the broader builder community.
+
+
+
+## Multigres
+
+
+
+Multigres is an open source operating system for Postgres, built by the team behind Vitess. It adds scalable connection pooling and automated multi-node failover to Postgres out-of-the-box. With Multigres, there's no separate pooler to run, and your app can connect far more clients than one Postgres instance can hold.
+
+Many developers are familiar with basic Primary / Standby HA architecture and its known issues. Traditionally, if the primary database fails before data has been replicated to the standby, those rows may be lost. In contrast, Multigres uses a generalized consensus protocol built on top of postgres synchronous replication. If a Multigres node fails, the cluster agrees on exactly which writes were committed before accepting new ones, then promotes a replica in seconds. You keep every committed write through the failover.
+
+Multigres runs three Postgres nodes across availability zones in one region, so losing one zone doesn't take your database down. You don't need to change your application code to move to Multigres.
+
+You can also add read replicas and gateways for more read throughput and client connections. During the alpha, our team adds them for you.
+
+Multigres is in private alpha, by invite. It works with Supabase Auth, Storage, and Edge Functions, and it's built for testing during the alpha, not production workloads. [Request access](https://supabase.com/go/multigres-early-access).
+
+
+
+## OrioleDB
+
+
+
+OrioleDB is an open source, scalable storage engine for Postgres. It replaces Postgres traditional heap storage and eliminates its fundamental limitations, such as table bloat, VACUUM overhead, and txid wraparound inherent to the limited range of 32-bit transaction IDs.
+
+With heap storage, Postgres never updates a row in place: every update writes a new row version and leaves the old one behind as a dead tuple. On hot tables with frequent updates and deletes, this creates significant bloat over time, and cleaning it up requires constant VACUUM activity. VACUUM is one of the most common causes of Postgres performance degradation and outages under load. Teams typically mitigate it with careful tuning, scheduled `pg_repack` runs, and over-provisioned compute.
+
+OrioleDB's undo log removes this problem at the source. Instead of leaving dead tuples behind, updates and deletes write page-level undo records, which the system reclaims automatically. This eliminates bloat entirely and VACUUM is no longer needed.
+
+Allowing lock-free page reads also makes OrioleDB more efficient under high concurrency, especially in IOPS use. OrioleDB delivers up to 1.8x higher throughput than Postgres heap in our public, TPC-C-derived benchmarks, published on [dbarena.com](https://dbarena.com/).
+
+
+
+[dbarena.com](https://dbarena.com) publishes open, reproducible database benchmarks across providers: the benchmark code, published methodology, downloadable raw data per result, and shareable comparison links. It compares Supabase, Amazon RDS, and Google Cloud SQL at launch. For each run, dbarena reports transactions per dollar, monthly total cost, transactions per minute, p95, and machine specs, and it plots throughput over time.
+
+Developers evaluating hosted Postgres have few trustworthy sources for comparing providers. Vendor benchmarks often run under favorable conditions, community benchmarks are one-off snapshots, and a rigorous in-house evaluation costs weeks to produce.
+
+dbarena follows three rules: every published result can be checked independently, comparisons are normalized for cost, and the methodology is public.
+
+Subscribe to the [dbarena newsletter](https://dbarena.com/?subscribe) to keep up with the latest comparisons and performance tracking over time.
+
+## Get started
+
+- Multigres: private alpha. [Request access](https://supabase.com/go/multigres-early-access).
+- OrioleDB: create a new project and choose OrioleDB at project creation. Public beta. [Docs](https://supabase.com/docs/guides/database/orioledb).
+- dbarena: public, at [dbarena.com](https://dbarena.com).
diff --git a/apps/www/_blog/2026-10-02-supabase-is-acquiring-turso.mdx b/apps/www/_blog/2026-10-02-supabase-is-acquiring-turso.mdx
new file mode 100644
index 00000000000..b59095b83b2
--- /dev/null
+++ b/apps/www/_blog/2026-10-02-supabase-is-acquiring-turso.mdx
@@ -0,0 +1,43 @@
+---
+title: 'Supabase is acquiring Turso'
+description: 'Supabase is acquiring Turso to build the database infrastructure for agentic AI'
+author: paul_copplestone
+date: '2026-10-02T09:00:00'
+categories:
+ - company
+tags:
+ - ai
+ - open-source
+ - database
+imgSocial: '2026-10-02-supabase-is-acquiring-turso/thumb.png'
+imgThumb: '2026-10-02-supabase-is-acquiring-turso/thumb.png'
+toc_depth: 2
+---
+
+AI is enabling builders to create an immense amount of software. Today, agents are spinning up millions of databases to power the prototypes, explorations, dashboards, and apps they're building. This new pattern, at this massive scale, requires an evolution in database infrastructure. Turso is joining Supabase to build this evolution.
+
+For existing users, nothing changes. Supabase will continue building around Postgres, while Turso will continue its work on SQLite. And together, we’re creating something new that will bring the Supabase experience to every agent.
+
+## Databases for agents
+
+Supabase is already launching over one million databases per week. As agents build more software, we believe database demand will outpace the world’s current capacity to support them. So we need infrastructure that can scale to meet this growth and is suited to how we build with agents.
+
+Agents should be able to create a database as easily as creating a file, with just as little concern about cost. For smaller workloads, that shouldn’t require provisioning a dedicated machine every time. Databases should be cheap to create, available on demand, and have a clear path to production when needed.
+
+SQLite is well suited to these small, on-demand workloads. Postgres is what you want as your application scales. We want builders to have the same developer experience from prototyping to production.
+
+## Turso
+
+Turso has built an architecture for exactly this pattern. They rebuilt SQLite in Rust and created a cloud platform where a single server can manage millions of databases, loading them when needed and suspending them when they’re not.
+
+This architecture makes it possible to provision a database for each agent on demand, whether on Turso Cloud or in customers’ own clouds, as Superhuman, Sauna.ai, CTO.new, and Mastra do.
+
+We share a vision for how infrastructure needs to evolve to support agentic AI. Turso will continue operating, with a clear path into the broader Supabase ecosystem as workloads grow.
+
+## Open source
+
+Turso and Supabase have a lot in common: a commitment to open source, a focus on developer experience, and an appetite to tackle hard infrastructure problems.
+
+We’re excited to welcome Glauber Costa and Pekka Enberg to Supabase with the rest of the Turso team. Glauber will lead this agentic infrastructure effort.
+
+Our mission is to store the world’s data, and agents are going to create a lot more of it. This gets us closer to that goal.
diff --git a/apps/www/_blog/2026-10-02-supabase-select-2026-recap.mdx b/apps/www/_blog/2026-10-02-supabase-select-2026-recap.mdx
new file mode 100644
index 00000000000..ac676a592e5
--- /dev/null
+++ b/apps/www/_blog/2026-10-02-supabase-select-2026-recap.mdx
@@ -0,0 +1,99 @@
+---
+title: 'Supabase Select 2026 Recap'
+description: 'Build anything, operate with confidence, scale without limits. Supabase carries your application from prototype to petabyte.'
+author: oli_rice, inian, jonny
+date: '2026-10-02T10:50:00'
+categories:
+ - product
+tags:
+ - ai
+ - mcp
+ - postgres
+imgSocial: 'supabase-select-2026-recap/og.png'
+imgThumb: 'supabase-select-2026-recap/thumb.png'
+toc_depth: 2
+---
+
+Today at Supabase Select, we showed how Supabase works for your app from day one to millions of users, and how your agent builds and runs it with you.
+
+Your coding agent already writes your application code. Setting up the backend is still your job. So is watching it in production and fixing it when it breaks. That work happens in the dashboard and the docs, and your agent can't do it end to end.
+
+Supabase now works code first. Schema and config can live in code, so your agent can set up and change a project the same way you do. It can also check the project and report the problems it finds. You decide what gets fixed and merged.
+
+You can build anything, because your agent works in the same code you do. You can operate with confidence, because your agent finds problems and you decide what merges. And you can scale without limits, because when the app grows, the same Postgres carries it from prototype to petabyte.
+
+## Build anything
+
+### Local development without Docker
+
+Local Supabase can now run as native processes, so it starts on machines without a Docker daemon, like Claude Code's sandbox. You can also run multiple local Supabase instances, one per directory, so several checkouts of the same repo run at the same time. In alpha, off by default. Update the [Supabase CLI](https://supabase.com/docs/guides/local-development/cli/getting-started) to try it.
+
+### Declarative Schemas 2.0
+
+Write your schema as SQL files and pg-delta generates the migration, so the schema lives in your repo. Project settings live in code too, and a dashboard change comes back into the file with `supabase config pull`. [Docs](https://supabase.com/docs/guides/local-development/declarative-database-schemas).
+
+### Supabase Compute
+
+Run web services and agents in any language next to your database, with no limit on how long they run. Each service gets a full Linux environment and the same default environment variables as your Edge Functions. Private alpha. [Join the waitlist](https://supabase.com/compute).
+
+### Your app's MCP server
+
+Let your users connect their own agents to your app. The server runs as an Edge Function next to your data, users sign in through your existing Auth flow, and every tool call runs as that user, with your RLS policies deciding what it can reach. It's separate from the official Supabase MCP server, and it's built on `@supabase/server` and the new Supabase Middleware, which also work on their own in any server code that needs to know who is signed in. [Add the MCP server block](https://supabase.com/library/docs/headless/mcp).
+
+Learn more in [Build anything: Supabase from code, and an MCP server for your app](https://supabase.com/blog/select-2026-build-anything).
+
+## Operate with confidence
+
+### Agent prompts
+
+Pick a prompt and suggested schedule for health, security, performance, or resource checks, and run it in Claude, Codex, or Cursor. Your agent reads your project through the Supabase MCP server, connected read-only, and reports what it finds. [Pick a prompt](https://supabase.com/docs/guides/observability/automate-with-agents).
+
+### Health Check Advisors
+
+Advisors now flag elevated error rates in the Data API, Auth, Storage, and Edge Functions, next to the security and performance issues they already catch. Open the Health tab on your project's Advisors page. [Changelog](https://supabase.com/changelog/50577-health-check-advisors).
+
+### Database Connections
+
+See which sessions hold connections, run long, or are blocked, and who holds the lock, then cancel the query or terminate the connection. On by default for every project, including self-hosted. [Open it in the dashboard](https://supabase.com/dashboard/project/_/observability/connections).
+
+### `query_logs` and the Supabase agent skill
+
+A new MCP tool lets your agent query your logs directly, and the Supabase agent skill now points to a living document of the health, security, performance, and resource signals your agent should watch for. [Install the Supabase plugin](https://supabase.com/docs/guides/ai-tools/plugins).
+
+### Explorer and Notebooks
+
+Explorer is the next version of the SQL editor. Query your logs or your database in one workspace, and save the investigation as a Notebook anyone on your team can rerun. Rolling out to every project through October 12. Once it reaches your project, turn it on under Feature Previews. [Open Explorer](https://supabase.com/dashboard/project/_/explorer).
+
+### Enterprise-Managed Auth for MCP
+
+Your company decides who can connect to the Supabase MCP server through its identity provider, starting with Okta. Each token is bound to the member who signs in. Generally available. [Set it up](https://supabase.com/docs/guides/platform/sso/enterprise-mcp-authentication) on a Team or Enterprise plan with SSO configured.
+
+### Scoped Personal Access Tokens
+
+Limit a token to the organizations, projects, and permissions you choose. Generally available, and the default for new tokens created in the dashboard. Create one at [Account, Access Tokens](https://supabase.com/dashboard/account/tokens).
+
+### MCP Elicitations
+
+Before your agent creates a paid project or branch, or runs SQL that could delete data, the Supabase MCP server asks you to confirm first. It helps prevent unwanted charges and data loss, but it isn't a guarantee. On by default. [MCP docs](https://supabase.com/docs/guides/ai-tools/mcp).
+
+### Supabase Pipelines, new destinations
+
+Stream Postgres data to BigQuery, ClickHouse, DuckLake, or Snowflake in near real time, so analytics queries run there instead of on your production database. Public alpha on the Pro, Team, and Enterprise plans. [Docs](https://supabase.com/docs/guides/database/replication/pipelines).
+
+Learn more in [Operate with confidence](https://supabase.com/blog/select-2026-operate-with-confidence).
+
+## Scale without limits
+
+### Multigres
+
+Multi-node high availability for Postgres, built by the team behind Vitess. When a node fails, Multigres promotes a replica in seconds and committed writes survive, with no changes to your application. Connection pooling is built in. The Multigres project is open source. On Supabase, it's in private alpha, by invite. [Request access](https://supabase.com/go/multigres-early-access).
+
+### OrioleDB
+
+A storage engine that replaces the default heap with an undo log, avoids table bloat and VACUUM, and keeps familiar Postgres behavior. Public beta. Choose it at project creation. [Docs](https://supabase.com/docs/guides/database/orioledb).
+
+### dbarena
+
+Open, reproducible database benchmarks. The benchmark code, the data, absolute throughput, and throughput per dollar are all published, so you can inspect the method and rerun the result. [Visit the website](https://dbarena.com).
+
+Learn more in [Scale without limits: Multigres, OrioleDB, and dbarena](https://supabase.com/blog/select-2026-scale-without-limits).
diff --git a/apps/www/_go/index.tsx b/apps/www/_go/index.tsx
index 1b4650ce11d..a5556ead938 100644
--- a/apps/www/_go/index.tsx
+++ b/apps/www/_go/index.tsx
@@ -38,8 +38,6 @@ import contestRules from './legal/contest-rules'
import byocEarlyAccess from './pre-release/byoc-early-access'
import multigresEarlyAccess from './pre-release/multigres-early-access'
import multigresEarlyAccessThankYou from './pre-release/multigres-early-access-thank-you'
-import supabasePipelinesNewDestinations from './pre-release/supabase-pipelines-new-destinations'
-import supabasePipelinesNewDestinationsThankYou from './pre-release/supabase-pipelines-new-destinations-thank-you'
import supabaseStripeProjects from './stripe-projects/supabase-stripe-projects'
const pages: GoPageInput[] = [
@@ -47,8 +45,6 @@ const pages: GoPageInput[] = [
awsActivateOffer, // maintain forever
exampleLeadGen, // sample lead gen page
byocEarlyAccess, // maintain until PM says to remove
- supabasePipelinesNewDestinations, // maintain while Pipelines destination early access is active
- supabasePipelinesNewDestinationsThankYou, // maintain while Pipelines destination early access is active
multigresEarlyAccess, // maintain while the Multigres private alpha is active
multigresEarlyAccessThankYou, // maintain while the Multigres private alpha is active
amoe, // maintain forever
diff --git a/apps/www/_go/lead-gen/ask-supabase-select.tsx b/apps/www/_go/lead-gen/ask-supabase-select.tsx
index 0a5858c10b8..f36b7172cc5 100644
--- a/apps/www/_go/lead-gen/ask-supabase-select.tsx
+++ b/apps/www/_go/lead-gen/ask-supabase-select.tsx
@@ -23,21 +23,30 @@ const themes: Theme[] = [
name: 'Build anything',
description:
"Your agent sets up the backend from code, your users' agents work with your app through its own MCP server, and long-running tasks run in Supabase Compute.",
- cta: { label: 'Read the Build Blog', href: '/docs' },
+ cta: {
+ label: 'Read the Build Blog',
+ href: 'https://supabase.com/blog/select-2026-build-anything',
+ },
icon: Hammer,
},
{
name: 'Scale without limits',
description:
'The app your agent built in minutes stays on the same Postgres, from prototype to petabyte.',
- cta: { label: 'Read the Scale Blog', href: '/docs' },
+ cta: {
+ label: 'Read the Scale Blog',
+ href: 'https://supabase.com/blog/select-2026-scale-without-limits',
+ },
icon: Maximize2,
},
{
name: 'Operate with confidence',
description:
'Your agent finds the problem, tests the fix, and reports what it found. You decide what ships.',
- cta: { label: 'Read the Operate Blog', href: '/docs' },
+ cta: {
+ label: 'Read the Operate Blog',
+ href: 'https://supabase.com/blog/select-2026-operate-with-confidence',
+ },
icon: ShieldCheck,
},
]
@@ -88,9 +97,13 @@ const page: GoPageInput = {
ctas: [
{
label: 'Read the Recap',
- href: '/docs',
+ href: 'https://supabase.com/blog/select-2026-build-anything',
variant: 'secondary',
},
+ {
+ label: 'Join our Discord',
+ href: 'https://discord.supabase.com/',
+ },
],
},
sections: [
diff --git a/apps/www/_go/pre-release/supabase-pipelines-new-destinations-thank-you.tsx b/apps/www/_go/pre-release/supabase-pipelines-new-destinations-thank-you.tsx
deleted file mode 100644
index b467fce7e9d..00000000000
--- a/apps/www/_go/pre-release/supabase-pipelines-new-destinations-thank-you.tsx
+++ /dev/null
@@ -1,26 +0,0 @@
-import type { GoPageInput } from 'marketing'
-
-const page: GoPageInput = {
- template: 'thank-you',
- slug: 'supabase-pipelines-new-destinations/thank-you',
- metadata: {
- title: 'Supabase Pipelines destination request received',
- description: 'Thanks for requesting early access to upcoming Supabase Pipelines destinations.',
- ogImage: '/images/blog/2025-12-02-introducing-supabase-pipelines/og.png',
- },
- hero: {
- title: 'Thanks for your request',
- subtitle: 'Early Access',
- description:
- "We received your destination preferences for Supabase Pipelines. If your workspace is selected for early access to ClickHouse, Snowflake, or DuckLake destinations, we'll reach out with next steps.",
- ctas: [
- {
- label: 'Back to Supabase',
- href: '/',
- variant: 'secondary',
- },
- ],
- },
-}
-
-export default page
diff --git a/apps/www/_go/pre-release/supabase-pipelines-new-destinations.tsx b/apps/www/_go/pre-release/supabase-pipelines-new-destinations.tsx
deleted file mode 100644
index c16ed311442..00000000000
--- a/apps/www/_go/pre-release/supabase-pipelines-new-destinations.tsx
+++ /dev/null
@@ -1,181 +0,0 @@
-import type { GoPageInput } from 'marketing'
-
-const page: GoPageInput = {
- template: 'lead-gen',
- slug: 'supabase-pipelines-new-destinations',
- metadata: {
- title: 'Supabase Pipelines Destinations - Early Access',
- description:
- 'Request early access to upcoming Supabase Pipelines destinations for ClickHouse, Snowflake, and DuckLake.',
- ogImage: '/images/blog/2025-12-02-introducing-supabase-pipelines/og.png',
- },
- hero: {
- title: 'Supabase Pipelines destinations',
- subtitle: 'Early Access',
- description:
- "Managed change-data-capture pipelines that replicate your Supabase Postgres data to analytical systems in near real time. Request early access to the destinations we're adding next: ClickHouse, Snowflake, and DuckLake.",
- image: {
- src: '/images/blog/2025-12-02-introducing-supabase-pipelines/thumb.png',
- alt: 'Introducing Supabase Pipelines',
- width: 2400,
- height: 1260,
- },
- ctas: [
- {
- label: 'Request early access',
- href: '#form',
- variant: 'primary',
- },
- {
- label: 'Read the announcement',
- href: '/blog/introducing-supabase-pipelines',
- variant: 'secondary',
- },
- ],
- },
- sections: [
- {
- type: 'feature-grid',
- className: 'border-y border-muted bg-surface-75 py-16 sm:py-24',
- title: 'Bring Supabase Postgres into your analytics stack',
- description:
- 'Pipelines keeps your application workload on Postgres while ongoing replication sends production changes to systems built for analytics, reporting, and lakehouse workflows.',
- columns: 3,
- items: [
- {
- title: 'ClickHouse',
- description:
- 'Replicate operational data into ClickHouse for high-volume analytical queries, dashboards, and event workloads.',
- },
- {
- title: 'Snowflake',
- description:
- 'Replicate Supabase Postgres data into Snowflake for warehouse analytics, BI, and governed data workflows.',
- },
- {
- title: 'DuckLake',
- description:
- 'Move data into an open lakehouse destination for portable analytics and long-term data workflows.',
- },
- ],
- },
- {
- type: 'form',
- id: 'form',
- className: 'py-4 sm:py-8',
- title: 'Request early access to new Pipelines destinations',
- description:
- "This form is for early access to upcoming destinations for Supabase Pipelines, not access to Supabase Pipelines itself. Tell us which destinations your team wants to use. If your workspace is selected, we'll reach out with next steps.",
- fields: [
- {
- type: 'email',
- name: 'email',
- label: 'Email address',
- placeholder: 'Work email',
- required: true,
- },
- {
- type: 'text',
- name: 'org_slug',
- label: 'Supabase organization slug',
- placeholder: 'acme-inc',
- description: 'Use the slug from your Supabase Dashboard URL, for example /org/acme-inc.',
- required: true,
- },
- {
- type: 'checkbox',
- name: 'destination_clickhouse',
- label: 'ClickHouse',
- description:
- 'For high-throughput analytical queries, event data, logs, and dashboard workloads.',
- group: 'requested_destinations',
- groupRequired: true,
- },
- {
- type: 'checkbox',
- name: 'destination_snowflake',
- label: 'Snowflake',
- description: 'For teams running warehouse analytics, BI, or governed data workflows.',
- group: 'requested_destinations',
- groupRequired: true,
- },
- {
- type: 'checkbox',
- name: 'destination_ducklake',
- label: 'DuckLake',
- description:
- 'For open lakehouse workflows where you want portable data and flexible analytics.',
- group: 'requested_destinations',
- groupRequired: true,
- },
- ],
- submitLabel: 'Request destination access',
- successRedirect: '/go/supabase-pipelines-new-destinations/thank-you',
- disclaimer:
- 'By submitting this form, I confirm that I have read and understood the [Privacy Policy](https://supabase.com/privacy).',
- crm: {
- notion: {
- database_id: '3825004b775f80828179e7bdd7ee4b8d',
- columnMap: {
- email: 'Email',
- org_slug: 'Organization Slug',
- destination_clickhouse: 'ClickHouse',
- destination_snowflake: 'Snowflake',
- destination_ducklake: 'DuckLake',
- },
- },
- },
- },
- {
- type: 'three-column',
- className: 'pb-16 sm:pb-24',
- title: 'Suggested reading',
- description: 'Get the product context and setup details behind Supabase Pipelines.',
- children: (
- <>
-
- Blog
-
- Introducing Supabase Pipelines
-
-
- Learn how managed CDC pipelines move Postgres changes to analytical destinations in
- near real time.
-
-
-
- Docs
-
- Set up Pipelines
-
-
- Review publications, destination setup, monitoring, and how pipelines are managed from
- the Dashboard.
-
-
-
- Guide
-
- Realtime or Pipelines?
-
-
- Compare live user experiences over WebSocket with reliable data movement into
- analytical systems.
-
-
- >
- ),
- },
- ],
-}
-
-export default page
diff --git a/apps/www/app/(products)/compute/_components/ComputeVisual.tsx b/apps/www/app/(products)/compute/_components/ComputeVisual.tsx
index c9520572ef0..c2f4922c572 100644
--- a/apps/www/app/(products)/compute/_components/ComputeVisual.tsx
+++ b/apps/www/app/(products)/compute/_components/ComputeVisual.tsx
@@ -1,5 +1,6 @@
'use client'
+import SectionContainerWithCn from 'components/Layouts/SectionContainerWithCn'
import { AnimatePresence, motion, useReducedMotion } from 'framer-motion'
import { Database } from 'icons'
import type { LucideIcon } from 'lucide-react'
@@ -7,7 +8,6 @@ import { Bot, User } from 'lucide-react'
import { useCallback, useEffect, useId, useRef, useState } from 'react'
import { cn } from 'ui'
-import SectionContainerWithCn from '../../../../components/Layouts/SectionContainerWithCn'
import styles from './compute-visual.module.css'
import { ComputeLogo } from './ComputeLogo'
@@ -185,6 +185,7 @@ function ComputeCardHeader({
- Every sandbox and service inherits your project's auth, roles, and permissions the moment - it starts, running in its own microVM with dedicated CPU and memory. Agents get a sandbox - that is already scoped to the data it is allowed to touch — nothing more. + Every sandbox and service inherits your project's auth, roles, and permissions the + moment it starts, running in its own microVM with dedicated CPU and memory. Agents get a + sandbox that is already scoped to the data it is allowed to touch — nothing more.