Careers

Senior Frontend Engineer, Onchain

AI Infrastructure / Developer Ecosystem

Sapien spent two years running one of the largest AI data validation operations in the industry, processing 195 million tasks for companies like Amazon Zoox, MidJourney, and Alibaba. Now we're building the infrastructure we wished existed: PoQ, an open, onchain protocol that gives AI teams verifiable quality signals they can prove, not just claim. We're hiring a Senior Frontend Engineer who can make a complex protocol feel simple to use without hiding the detail and control that technical users need.

Why Join

The design challenge here is real: PoQ involves staking, consensus, slashing, and onchain attestations. The people using these interfaces are technical. They want clarity and control, not a simplified version of what is actually happening. Getting that balance right takes genuine craft.
Small team. The people who designed the protocol are still here. You will work directly with them and your decisions will shape how the product evolves.
The protocol runs in real production pipelines for enterprises in AI, robotics, and autonomous systems.
Competitive salary, equity, and token upside.

Role Summary

We are looking for a frontend engineer with a strong eye for design who understands the infrastructure behind what they are building. PoQ is a protocol with real complexity: staking mechanics, validator consensus, slashing conditions, onchain attestations, indexer state. Your job is to make that approachable without dumbing it down.

The users of these interfaces are developers and operators who know the protocol well. They want to see what is actually happening. A good design decision here is one that reduces friction without removing visibility. A bad one hides something a power user needed to see.

This is not a consumer product role. It is not UI for its own sake. The frontend is part of the protocol.

Core Responsibilities

Interface Design and Development

Design and build Sapien's core web applications in React and TypeScript
Translate protocol mechanics into interfaces that are clear and approachable without obscuring what is happening underneath
Make deliberate decisions about what to surface, what to simplify, and what to keep fully visible for technical users
Hold a high standard on both the visual quality and the functional correctness of what you ship

Onchain Integration

Implement wallet connection, signing, and transaction flows that handle real edge cases: pending transactions, reverts, partial finality
Integrate directly with smart contracts, indexers, and backend APIs
Know when to read from the chain directly, when to use indexed data, and when caching is appropriate
Design frontend data models that reflect what onchain state actually is, including where it is uncertain or in progress

Protocol Understanding

Work with smart contract and backend engineers early in the design process, not after contracts are finalized
Read contract interfaces and understand what they mean for the user experience
Bring frontend and UX constraints into protocol and SDK design while there is still room to act on them

Systems and Quality

Own the frontend architecture, state management, and data flow
Hold a high bar on typing, correctness, and testability
Build components and patterns that scale as the protocol grows
Treat performance and observability as ongoing work, not a final pass

Ideal Background

You have shipped production React and TypeScript applications and are comfortable working with onchain systems: wallets, RPCs, signing flows, event-driven data. You have a genuine eye for design and care about how things look, not just how they work.‍

You do not need to write Solidity, but you should be able to read a contract and understand what it means for the interface. Experience with smart contract interfaces and ABI-driven development is a strong plus. Relevant backgrounds include protocol teams, developer tooling, data-intensive dashboards, and infrastructure products where the users are technical.

What We're Looking For

Strong design sensibility alongside solid engineering fundamentals
A real understanding of how onchain systems behave in practice
The ability to abstract complexity in a way that preserves control for users who want it
You can reason from a contract interface to a user-facing design and explain the tradeoffs
You take full ownership of what you ship
Clear, direct communicator