In two sentences: Instant is a modern Firebase. We make you productive by giving your frontend a real-time database.

What does that actually mean?

Imagine you’re a hacker who loves building apps. You have an exciting idea, and are ready to make something people want. You want to build an MVP fast, that doesn’t completely suck. So how do you do it?

Most of the time we make a three-tier architecture with client, server, and a database. On the server side we write endpoints to glue our frontend with our database. We might use an ORM to make it easier to work with our db, and add a cache to serve requests faster. On the client we need to reify json from the server and paint a screen. We add stores to manage state, and write mutations to handle updates. This is just for basic functionality.

If we want our UIs to feel fast, we write optimistic updates so we don’t need to wait for the server. If we want live updates without refreshing we either poll or add websockets. And if we want to support offline mode, we need to integrate IndexedDB and pending transaction queues.

That’s a lot of work!

To make things worse, whenever we add a new feature, we go through the same song and dance over and over again: add models to our DB, write endpoints on our server, create stores in our frontend, write mutations, optimistic updates, etc.

Could it be better? We think so! Instant compresses the schleps:

If you had a database on the client, you wouldn’t need to manage stores, selectors, endpoints, caches, etc. You could just write queries to fetch the data you want. If these queries were reactive, you wouldn’t have to write extra logic to re-fetch whenever new data appears. Similarly you could just make transactions to apply mutations. These transactions could apply changes optimistically and be persisted locally. Putting this all together, you can build delightful applications without the normal schleps.

So we built Instant. Instant gives you a database you can use in the client, so you can focus on what’s important: building a great UX for your users, and doing it quickly.

Instant is a real-time database you can use on the frontend. We give you the best of both Firebase and Supabase, a sync-engine with support for relations. This is the kind of tech that companies like Figma, Notion, and Linear build internally to power their products (Try out the demo)

We’re looking for a founding backend engineer to join our team in San Francisco. We’re looking for someone who:

1. Enjoys working on hard problems (we’re building a database company!)
2. Wants large scope and plenty of agency
3. Has an interest in learning or working in Clojure (we’re happy to induct you into the cult!)

Our current stack looks like so:

• We offer client SDKs, a CLI tool, and web GUI to interact with Instant. All written in Typescript
• We have a server written in Clojure for managing websocket connections, parsing queries, running permissions, and broadcasting novelty.
• All of which sits on top AWS Aurora Postgres

Here are the kinds of problems on the back-end we want to solve next:

We’re regularly handling >10k connections but will need to improve our infra across our query, transactions, permissions, and reactive layers to handle 100k connections and more.

Upgrade our permissions system. Right now Instant’s permission system is based on Google CEL, similar to Firebase. This has worked for now but we think we can do better. Figma created their own DSL for writing permissions and we’re thinking of doing something similar.

Enable BYOP (Bring your own Postgres). Today users can only use Instant via our hosted or self-hosted solution. Our vision though is that folks could bring their existing database and plug it into Instant’s sync engine. This would enable existing companies to readily adopt Instant.

These are all bigger projects, but there are a lot of quicker wins we can deliver too, like giving observability to our developers so they can identify and tune problematic queries.

Sound interesting? If so here’s a few more details :)

• Location: We're based in San Francisco, CA!
• In-person or open to relocation only: We're a small team and we really do prefer all working together in person!
• Compensation: Sliding scale between 0.5%-2% equity and 150k - 200k base + medical/dental/vision benefits

Our vision is to be the infrastructure for all apps of the future. If this jives with you we should really talk 🙂.

Our architecture is inspired by Figma’s LiveGraph and Asana’s LunaDB. We also built Instant to be multi-tenant and don’t need to spin up an actual database for users. This enables us to give users a database in <10ms with a click of a button. And unlike our competitors, we can offer a free tier to users where their projects are never paused and there is no limit to the number of active projects they can have.

To learn more about how Instant works under the hood, check out our essay A Graph-Based Firebase:

https://www.instantdb.com/essays/next_firebase