Location
Remote
Job Type
full-time
Work Format
🌍 Remote Worldwide
Salary
Not specified
Posted
August 13, 2026

Job Description

About Supabase

Supabase is the Postgres development platform, built by developers for developers. We provide a complete backend solution including Database, Auth, Storage, Edge Functions, Realtime, and Vector Search. All services are deeply integrated and designed for growth.

About the Role

We're looking for a SDK Engineer - JavaScript to join the SDK team and own a core part of how developers talk to Supabase from JavaScript and TypeScript.

Our JS/TS SDKs are the front door to the platform: database queries, auth, storage, realtime subscriptions and edge functions, used by a very large number of developers and by most of the AI coding tools building on Supabase today.

This is a library-authoring role, and the work happens in the open: public repos, public issue trackers, and API decisions whose consequences are permanent. The type system here is a design surface rather than a formality. If you get satisfaction from an inference that Just Works, from a migration guide that saves people an afternoon, and from an issue tracker that isn't a graveyard, you'll like it here.

This role is ideal for someone who thrives in async, fast-paced environments and is excited about building developer tools that scale to millions.

What You'll Be Responsible For

  • Build and evolve our JavaScript/TypeScript SDKs.

  • Start new things. Alongside the maintenance work, you're expected to find what's missing, make the case for it, and build it. Some of what we ship next doesn't exist yet, and nobody will hand you the list.

  • Work in the open. These are public repos: you'll triage inbound issues, review and shepherd outside contributions, keep CI and release automation healthy, and hold a clear, kind line on scope.

  • Own the type experience. Keep generated database types flowing correctly through the client APIs so autocomplete and inference stay correct in real codebases.

  • Keep us honest across runtimes. Node, Deno, Bun, browsers, Cloudflare Workers, React Native/Expo, including dual ESM/CJS publishing and types that resolve correctly under every module resolution mode. Test it, don't assume it.

  • Work on realtime. Long-lived WebSocket connections, reconnection, and subscription and presence semantics.

  • Track the platform. When auth, realtime, storage, postgrest or edge-runtime ship a change, make sure the SDKs reflect it, and that we say so in the changelog.

  • Design in public. Write the RFCs, migration guides, release notes and docs. Treat a breaking change as a deprecation path plus a migration story, not a version bump.

  • Make our SDKs legible to AI coding agents, which are now a major consumer of them.

You Might Be a Good Fit If You

  • Expert-level TypeScript. You use generics, conditional and mapped types as design tools, you can explain why an inference breaks.

  • You've authored or maintained a published library with a public API and consumers outside your own company. You know what it costs to change something people depend on.

  • You've worked on open-source projects and know the maintainer side of them. Issue triage at volume, reviewing outside PRs, release automation, changelogs and semver, security reports, and saying no to a feature request without losing the person who asked.

  • npm packaging fluency: dual ESM/CJS builds, export maps, type resolution, semver discipline, and the failure modes consumers actually hit.

  • Testing as a habit: unit, type-level and end-to-end against a real stack. Every fix comes with a regression test.

  • Strong written communication. Design docs, changelogs and issue replies are a large part of the output here, much of it public, and we're async by default.

  • Real autonomy: you find the important work, scope it, ship it, and say what you didn't do.

  • Communicate clearly across both technical and non-technical audiences.

  • Have experience in async or globally distributed teams.

  • Are energized by solving real-world problems for developers.

  • Are comfortable navigating ambiguity and moving quickly.

What We Offer

  • Fully Remote

    We hire globally. We believe you can do your best work from anywhere. There are no Supabase offices, but we provide a WeWork membership or co-working allowance you can use anywhere in the world.

  • ESOP

    Every team member receives ESOP (equity ownership) in the company. We want everyone to share in the upside of what we’re building together.

  • Tech Allowance

    Use this budget to set up your ideal work environment—laptop, monitor, headphones, or whatever helps you do your best work.

  • Health Benefits

    Supabase covers 100% of health insurance for employees and 80% for dependents, wherever you are. Your wellbeing and your family’s health are important to us.

  • Annual Off-Sites

    Once a year, the entire company gathers in a new city for a week of connection, collaboration, and fun. It’s a highlight of our year.

  • Flexible Work

    We operate asynchronously and trust you to manage your own time. You know what needs to be done and when.

  • Professional Development

    Every team member receives an annual education allowance to spend on learning—courses, books, conferences, or anything that supports your growth.

About the Team

Supabase was born-remote and open-source-first. We believe our globally distributed team is our secret weapon in building tools developers love.

  • ~400 team members

  • 60+ countries

  • 20+ languages spoken

  • Over $1B raised (including our $500M Series F)

  • 540,000+ community members

We move fast, build in public, and use what we ship. If it’s in your project, we probably use it in ours too. We believe deeply in the open-source ecosystem and strive to support—not replace—existing tools and communities.

🎯 Who is this job for?

Level: Senior SDK or library engineer with expert-level JavaScript/TypeScript skills and experience independently owning public, production-grade APIs.

Required skills: Advanced TypeScript typing, npm packaging, dual ESM/CJS publishing, runtime compatibility across Node, browsers, Deno, Bun, Cloudflare Workers, and React Native, automated testing, WebSockets, open-source maintenance, and clear technical writing.

Suitable candidates should be familiar with designing and evolving SDKs, maintaining backward compatibility, managing releases and CI, triaging issues, reviewing community contributions, supporting realtime features, writing migration guides and RFCs, and working autonomously in async distributed teams.

💬 Potential Interview Questions

How would you design TypeScript generics so generated database types flow correctly through a JavaScript SDK’s query builder?

I would parameterize the client and query builder with the generated database schema, then use mapped and conditional types to derive table, row, insert, update, and relationship types. The API should preserve inference through chained calls without requiring users to manually annotate common queries.

What are the main challenges of publishing a package that supports ESM, CommonJS, and multiple TypeScript module resolution modes?

The package must provide correct conditional exports for runtime and type entry points, with compatible ESM and CommonJS builds. I would test Node, bundlers, and TypeScript configurations such as Node16, NodeNext, and Bundler resolution to catch mismatches between import paths and declarations.

How would you design a reliable WebSocket reconnection strategy for realtime subscriptions?

I would use exponential backoff with jitter, distinguish transient failures from authentication or authorization errors, and restore subscriptions only after the connection is ready. The client should expose clear connection states and avoid duplicate subscriptions during reconnect races.

How would you test a JavaScript SDK across Node, Deno, Bun, browsers, Cloudflare Workers, and React Native?

I would maintain runtime-specific integration suites and use portable APIs such as configurable fetch, WebSocket, timers, and storage adapters where necessary. CI should run representative tests in each environment and verify both runtime behavior and type resolution from the published package.

What should an SDK release process include when a platform service introduces a breaking API change?

I would document the change in an RFC, introduce deprecations where possible, provide a migration guide and regression tests, and classify the release according to semantic versioning. The changelog should clearly explain affected APIs, upgrade steps, and compatibility concerns.

How would you prevent duplicate or inconsistent presence state in a realtime client?

I would define explicit semantics for joins, leaves, updates, and reconnects, and maintain presence state using deterministic identifiers and idempotent event handling. Tests should cover out-of-order messages, duplicate events, reconnect synchronization, and concurrent updates.

How do you approach type-level testing for a public TypeScript SDK?

I would add compile-time tests that assert expected inference, accepted inputs, rejected inputs, overload behavior, and generated schema compatibility. These tests should run against realistic user code so accidental widening to any or breaking inference is detected before release.

How would you investigate a report that an SDK works in Node but fails in a Cloudflare Worker?

I would compare the environments for available globals, module format, WebSocket behavior, crypto APIs, timers, and filesystem or process dependencies. I would reproduce the issue in a worker-compatible test harness, remove unsupported assumptions, and add a runtime-specific regression test.

What principles would you use when reviewing an external pull request for a public SDK?

I would evaluate API consistency, backward compatibility, type quality, runtime portability, test coverage, documentation, and maintenance cost. Feedback should be specific and respectful, while scope decisions should be explicit so contributors understand both the technical and product rationale.

How can an SDK be made easier for AI coding agents to use correctly?

It should expose predictable APIs, strong type definitions, descriptive errors, discoverable method names, and concise examples for common workflows. Documentation should include complete end-to-end patterns, clearly state authentication and runtime requirements, and avoid ambiguous overloads or undocumented behavior.

📋 Job Summary

Supabase is a remote-first, open-source Postgres development platform seeking a JavaScript SDK Engineer to shape the tools developers use to access Database, Auth, Storage, Realtime, Edge Functions, and Vector Search. You’ll build and evolve public JavaScript/TypeScript libraries, own type inference and npm packaging, support Node, Deno, Bun, browsers, Cloudflare Workers, and React Native, and improve realtime, testing, releases, documentation, and AI-agent usability. This is a fully remote, async full-time role with global hiring, equity, health coverage, tech and professional-development allowances, and an undisclosed salary. Apply to make high-impact developer tools used by millions while working openly with a distributed team across 60+ countries.

Required Skills

JavaScript TypeScript Node.js React Native WebSocket npm Git

Never miss a JavaScript opportunity

Subscribe to get similar jobs and weekly insights delivered to your inbox

Hiring JavaScript developers?

Post your job to 7,800+ registered developers. Starting free.

See Pricing

Related jobs

Europe

Senior Frontend Engineer

Coinspaid Solutions

Full-time
Poland, Spain, Serbia, Portugal, Cyprus

AI-Native Fullstack Engineer (Go + React)

COLIBRIX ONE

Full-time

Is this your listing? Claim or request removal