I deployed my first Supabase Edge Function in January 2026 — a webhook handler that received Stripe payment events, validated them against the Supabase auth system, and inserted records into a Postgres table with row-level security enforced at the database layer. I have since deployed twelve more functions handling authentication callbacks, file processing triggers, API endpoints for a mobile app, and a scheduled cleanup job. After five months of production use alongside Cloudflare Workers and AWS Lambda functions that serve the same application, I have a clear picture of where Supabase Edge Functions deliver unique value and where they fall short of the alternatives.
The Deno Runtime: TypeScript Without the Build Chain
Supabase's decision to use Deno as the Edge Functions runtime is the most consequential architectural choice in the product, and it took me about two weeks of use to understand why it matters. A Deno-based Edge Function is a single TypeScript file — no tsconfig.json, no bundler configuration, no node_modules, and no build step. You write a handler function that receives a Request and returns a Response, deploy it with supabase functions deploy, and it runs.
When I built the same Stripe webhook handler as a Cloudflare Worker, the workflow required installing wrangler, configuring a wrangler.toml file, writing the handler in a module syntax that esbuild could bundle, and managing a separate build step that produced the bundled output. With AWS Lambda and the Serverless Framework, the workflow required a serverless.yml configuration, a deployment package build step, and IAM role configuration that took three iterations to get right because the function needed both DynamoDB and SQS permissions. The Supabase Edge Function workflow eliminated all of that: I wrote a stripe-webhook/index.ts file, ran supabase functions deploy stripe-webhook, and the function was live at https://[project-ref].functions.supabase.co/stripe-webhook in approximately 40 seconds from deploy command to working endpoint.
The Deno standard library provides web-standard APIs that eliminate dependency overhead. Request and Response are native types, fetch is available without importing node-fetch, crypto.subtle handles JWT verification and HMAC signing without a library, and URLPattern provides route matching. My Stripe webhook handler — including Stripe signature verification, database writes, and error responses — is 94 lines of TypeScript with zero npm dependencies. The equivalent Node.js version with Express, the Stripe SDK, and a database client would require a package.json with 8 to 12 dependencies and a bundler configuration.
The Database and Auth Integration Is the Real Differentiator
The feature that sold me on Edge Functions — and the feature that has kept me using them for new endpoints — is the pre-wired integration with the Supabase platform. When an Edge Function receives a request, the Supabase client is available in the execution context with the project's API key, database URL, and authentication token already configured. If the request includes a Supabase auth token in its Authorization header, the client automatically validates it against GoTrue, identifies the user, and enforces Row Level Security (RLS) policies at the database layer.
I want to illustrate this with a concrete example. My application has an API endpoint that returns a user's order history. The endpoint requires that the user is authenticated and that the query only returns rows where user_id matches the authenticated user. On Supabase Edge Functions, the implementation is a database query that the RLS policy scopes automatically — the function does not need to extract the user ID from the token, validate it against the auth system, or add a WHERE clause to every query. On Cloudflare Workers, the same endpoint required 62 lines of TypeScript just for auth plumbing: extracting the JWT from the Authorization header, fetching the JWKS endpoint from GoTrue, verifying the token signature, extracting the user ID from the claims, and passing it as a parameter to every database query. The Workers version works, but it required maintaining authentication code that Supabase Edge Functions handle in zero lines.
Edge Functions share the same JWT secret as your Supabase project. When a function receives a request with a valid Supabase auth token, the Supabase client inside the function automatically inherits the user's identity and enforces Row Level Security policies. In my Stripe webhook handler, the function validates the webhook signature from Stripe, looks up the Supabase user by email in the Stripe event, and writes to a
billing_eventstable — all without manually managing auth tokens or database permissions.
The integration extends to storage triggers. I configured an Edge Function to fire on every file upload to a Supabase storage bucket, which runs an image resizing pipeline through the sharp library (available via Deno's npm compatibility layer). The function receives the file metadata in the event payload, downloads the original from storage, generates three resized variants, and uploads them back to the same bucket. This pattern — serverless function triggered by a platform event, with direct access to the platform's storage and database — would require a queue, an event bus, and IAM role configuration on AWS. On Supabase, it is a configuration option and a handler function.
Where the Limits Start to Hurt
I need to be direct about the constraints, because the 10-second execution timeout and 256 MB memory limit have forced me to move workloads off Edge Functions twice in five months.
The first time was a batch processing job that needed to generate monthly invoice PDFs for approximately 1,200 users. The job required querying the database for each user's billing records, rendering an HTML template to PDF, and uploading the result to storage. Each PDF generation took approximately 2.5 seconds, and processing 1,200 users sequentially would exceed the 10-second timeout by two orders of magnitude. I attempted to parallelize by triggering one function invocation per user, but the function's memory limit prevented loading the HTML template library and a full user record simultaneously for the largest accounts. I moved the job to an AWS Lambda function with a 15-minute timeout and 1,024 MB of memory, where it completes in approximately 52 seconds for all 1,200 users. The Lambda function costs about $0.35 per monthly run and required IAM configuration, but the Supabase Edge Function could not complete the workload at all within its constraints.
The second time was a data export endpoint that needed to stream a CSV file of query results to the client. The function's memory limit prevented loading the full result set into memory — the largest export was approximately 180 MB of raw data — and the function has no streaming response capability. I ended up generating the export through a database function that wrote to a storage bucket and returning a signed URL, which worked but added complexity that a streaming response would have avoided.
The Deno ecosystem is also smaller than Node.js. When I needed to use the @stripe/stripe-js package for client-side Stripe integration — not the webhook handler, but a checkout session creation endpoint — the npm compatibility layer handled it, but the import took approximately 800 milliseconds of cold-start time to resolve the dependency graph. Hot starts (subsequent invocations within the same deployment) were faster at around 40 milliseconds, but the cold-start penalty for npm packages through the compatibility layer is worth measuring for latency-sensitive endpoints. For packages that have native Deno equivalents — std/http, std/crypto, std/encoding — the import is near-instant.
The Local Development Experience Saves Real Time
Supabase's local development environment is one of the platform's strongest selling points, and it works as advertised for Edge Functions. Running supabase start launches a complete local Supabase instance in Docker: Postgres, GoTrue for auth, a storage API compatible with the production storage service, and the Edge Functions runtime. My entire development workflow — writing function code, testing against the local database with RLS policies, simulating auth flows, and verifying storage triggers — runs on my laptop with no network dependency.
I timed my development cycle for a new function compared to Cloudflare Workers. On Supabase, writing the function, testing it locally, and deploying it took 23 minutes from first line of code to verified production endpoint. On Cloudflare Workers, the same function took 41 minutes — 18 minutes of which was spent configuring wrangler dev to proxy auth requests to the remote Supabase instance because Cloudflare's local runtime cannot replicate Supabase's auth integration.
The log and debug experience has improved since early 2026. The dashboard shows invocation counts, error rates, and execution durations per function. Real-time logs — streaming console output from deployed functions — became available on the Pro plan in March 2026 and display console.log, console.error, and unhandled exception traces with stack frames. When I need more detailed tracing, I add structured JSON logging to the function's console output and parse it through an external observability platform, which is not as integrated as AWS CloudWatch but works without additional infrastructure.
When I Choose Edge Functions Over Workers or Lambda
After five months and twelve production functions, my decision framework is straightforward. I choose Supabase Edge Functions when the function's primary job is to mediate between the client and the Supabase database or storage layer — CRUD endpoints, auth-protected API routes, webhook handlers that write to the database, and file processing triggers. The pre-wired integration saves development time and eliminates auth plumbing that would require writing and maintaining code on any other platform. For a function that queries the database, validates an auth token, and returns a JSON response, an Edge Function typically takes half to one-third the lines of code of an equivalent Cloudflare Worker or Lambda function.
I choose Cloudflare Workers when the function needs to run in multiple geographic regions for latency reasons and when the function does not primarily interact with Supabase — proxy endpoints, redirect logic, A/B testing middleware, and API gateways that route to multiple backends. Workers deploy to 300-plus locations globally, while Supabase Edge Functions deploy to a smaller set of regions that maps to Supabase's infrastructure footprint. For a function that needs to respond in under 50 milliseconds from anywhere in the world, Workers' physical footprint is the deciding factor.
I choose AWS Lambda when the function needs to run for more than 10 seconds, use more than 256 MB of memory, or access AWS services that are not available through Supabase — SQS, DynamoDB, EventBridge, or Step Functions. Lambda's 15-minute timeout and 10 GB memory ceiling make it the only option for batch processing, report generation, and CPU-intensive workloads. I use Lambda as the complement to Edge Functions, not as a replacement — Lambda handles the heavy lifting, and Edge Functions handle the request-response layer.
Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.