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 Full-stack Engineer To Join Our Team In San Francisco. We’re Looking For Someone Who

• Wants to build front-end tech (read: a sync engine!) to enable devs to build delightful applications
• Enjoys crafting UIs that people use for hours
• 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 w/ 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
  
  

Inside the SDK there's a client-side database which can run queries just the like the server does. The client-side DB is what makes it possible for Instant to work offline, and to get optimistic updates out of the box. And it's full of problems that make computer science textbooks come alive. Here are some opportunities for improvements we’d love your help on.

Better joins: the client runs a nested loop to implement joins. But as we increase how much we cache, nested loops could become a problem. Perhaps it's time to add hash joins!

Better indexes: we use a map of maps for our indexes. This works, but comparison queries will be less efficient then they have to be. Perhaps it's time to consider writing an OrderedSet

Better introspection: we built a state machine to manage how different events interact: websocket updates, connection changes, client / server changes. But it's quite hairy and hard to reason about. Can we make it easier to observe events and replay them? Perhaps we could look into the actor model or structured concurrency for inspiration.

Better local storage: we treat IndexedDB as a key values store and serialize large chunks of state. Can we serialize in smaller chunks instead?

Less re-renders: Right now queries can change more than is needed. We want every update to be finer-grained, so users have less re-renders.

There’s also new surfaces to be built. Right now we have a GUI sandbox that lets you run queries and transactions. This can be very useful for debugging but there’s a lot missing here. One of the biggest pain points users have is crafting and testing permissions. It would be great if we had a better experience for rapidly testing permission rules against data.

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 🙂.