Member of Technical Staff, Products

Sycamore; Palo Alto (CA); On-site; USD 140,000 - 210,000; Full time

Job summary

Sycamore is building the trusted agent operating system for the enterprise. You will build product surfaces across Sycamore Forge and Sycamore Guard, from the interface through the API and persistence behind it, and design interactions for asynchronous, streaming, long-running, and non-deterministic behavior.

The environment includes React and TypeScript with TanStack Router and Query, Zustand for state, Tailwind; Python cloud services on FastAPI with PostgreSQL, server-sent events, and

Qualifications

• Experience designing interfaces for asynchronous, streaming and non-deterministic systems.
• Evidence of shipping product software users rely on and care about.
• Ability to reason about accessibility, security and performance from first principles.

Responsibilities

• Build and own product surfaces across Sycamore Forge and Sycamore Guard, from the interface through the API and persistence behind it.
• Design interactions for asynchronous, streaming, long-running, and non-deterministic behavior.
• Build and maintain component libraries and design system used by products and generated apps.
• Ensure accessibility, responsiveness, and performance are core product requirements.
• Define typed contracts between frontend and backend and prevent drift at build time.
• Turn platform primitives into intuitive interfaces enterprises can trust.

Skills

Software engineering

Systems design

Accessibility

Security-minded

Non-determinism

AI-native

Tools

TypeScript

React

TanStack Router

Query

Zustand

Tailwind

FastAPI

PostgreSQL

Kubernetes

Job description

Build the product surface through which enterprises actually use agentic apps.

About Sycamore

Sycamore is building the trusted agent operating system for the enterprise. Our platform helps companies build, deploy, and orchestrate agentic apps that take on real operational work, with the security and control large organizations need.

We are a small, engineering-led team working directly with Fortune 500 enterprises. We have raised $65M from Coatue and Lightspeed, along with other investors and industry leaders.

Working on AI Products

Products owns product slices end to end. A typical change starts at a route in Sycamore Forge or Sycamore Guard, runs through the API behind it, the event stream that carries progress, whatever agent behavior it triggers, and the analytics that tell us whether it made anything better.

The recurring difficulty is that the thing you are building an interface for is non-deterministic and slow. A run takes minutes. Output arrives continuously and incompletely. Tools are called that the user did not explicitly ask for. Something needs approval. Something fails in a way that only makes sense if you can see what the agent was attempting. Conventional product patterns assume a request and a response, and most of them do not survive contact with this.

That makes measurement part of the job rather than a separate team's. Whether a change helped is often genuinely unclear, and the answer usually requires designing the evaluation as carefully as the feature.

What you will do

• Build and own product surfaces across Sycamore Forge and Sycamore Guard, from the interface through the API and persistence behind it.
• Design interactions for asynchronous, streaming, long-running, and non-deterministic behavior, including partial output, interruption, and failure.
• Build and maintain the component libraries and design system that our products and generated applications both depend on.
• Own accessibility, responsiveness, and performance as product requirements rather than a later pass.
• Design and maintain typed contracts between front end and back end, and make drift a build failure.
• Turn powerful platform primitives into interactions that enterprise users can understand and trust.

The environment you will work in

Our current product environment includes React and TypeScript with TanStack Router and Query, Zustand for state, and Tailwind; Python cloud services on FastAPI with typed data models and PostgreSQL; server-sent events for streaming; durable workflows; and cloud-native deployment on Kubernetes.

TypeScript is strict, and our component libraries are contract-tested so that a breaking change to a public interface fails at compile time rather than in a generated application. We test with Vitest and Playwright, including component harnesses and screenshot coverage, and we use coding agents, traces, evaluations, and production feedback as part of everyday engineering.

This is context, not a checklist. We do not require previous experience with every framework or library in our stack. Strong engineers who understand systems, care about interface quality, and have shipped production software can become effective here without matching our tools one for one.

What we are looking for

• 5-12 years of software engineering experience. We will make exceptions for exceptional people in either direction.
• Comfort designing and interpreting product measurement for systems whose output varies run to run.
• Evidence that you have shipped and operated product software people actually used, and cared about how it felt.
• Product judgment. You can find the real problem behind a request and choose a useful first version.
• Accessibility as a default rather than a checklist item, and the ability to reason about it from first principles.
• A security-minded approach to enterprise data, permissions, and what an interface should refuse to show.
• Comfort with non-determinism. The systems you are building interfaces for do not behave identically twice.
• AI-native. You use coding agents and modern models as a force multiplier while still owning architecture, correctness, and operational outcomes.
• Comfort with startup ambiguity, fast feedback loops, and broad ownership.

Interview process

• A 30-minute introductory conversation.
• Two 60-minute technical interviews, one focused on systems design and one on coding.
• A take-home assignment where you build and present a real solution using the tools you would use on the job.

Why join

• Build the surface through which enterprises actually use agentic apps.
• Work on interface problems that are genuinely unsolved, because the systems underneath behave unlike anything interfaces were designed for.
• Own product slices end to end rather than a layer of them.
• Build components consumed by both people and language models, which is a stranger and more interesting problem than it sounds.
• Join early enough to shape the product architecture and the design system.
• Receive competitive cash compensation and meaningful equity in the company you are helping build.