Staff Product Designer, Render

• We're seeking candidates who possess high integrity, humility, and an insatiable drive to learn
• 7+ years of product design experience, ideally on developer tools, infrastructure, APIs, or another technical, credibility-driven product. You may have worked as a product designer, a designer who codes, or something harder to label — the title matters less than the work. At this level, we expect someone who has owned a major surface or product area end to end and set the direction others built against
• Craft that spans GUI and non-GUI surfaces. You have an eye for detail that borders on obsessive — the wording of an error, the shape of a command, the structure of an API response, the spacing of a dashboard — and you're as rigorous about a CLI message or an SDK method as you are about a screen. Your portfolio shows strong web UI work alongside text-first thinking: command design, API ergonomics, MCP/SDK design, docs-as-experience, or conversational interfaces
• You design the whole journey, not a surface at a time. Your portfolio shows end-to-end experiences — a user carried coherently across interface boundaries, CLI to API to SDK to dashboard and back — where you designed the model once and expressed it everywhere it appears, rather than polishing one surface in isolation
• A genuine point of view on what AI-native products mean for design — including how a product should show up to an agent, and not only to a person
• Comfort near code. You can read it, prototype with it, and collaborate with engineers without a translation layer in between
• The judgment to define quality where no established playbook exists, and the rigor to hold that bar once you've set it
• Clear, direct communication and cross-org influence. You can make the case for AX to technical and non-technical partners alike, in rooms where it's easy to treat it as purely an engineering concern — and you can align product, engineering, and leadership around a direction without formal authority over them
• This is a new category, and nobody has all the answers yet — including us. If you're the kind of designer who's curious enough to figure things out, ship, learn what's wrong, and try again, we'd love to hear from you
• If this role excites you but you don’t meet every single requirement, we’d still love to hear from you—your unique experience might be just what we need

Desirable

• Through reasoned discussions and continuous feedback, we strive to improve both individually and collectively
• We foster an environment of mutual trust and respect, empowering effective debate to achieve the best outcomes for our customers and team
• We especially encourage members of underrepresented groups in the tech community to apply and understand that not all successful candidates will meet each requirement listed
• Our interview process is unique to each role, and we value the candidate experience just as much as our customer experience
• We hope your conversations with us reflect a thoughtful process that is illuminative, enjoyable, and respectful of your time
• We're hiring a Staff Product Designer to own Agent Experience (AX) end to end — the whole programmatic surface and the whole loop: an agent deploys, a human reviews what happened, the agent hits an error and recovers, the human grants it exactly the access it needs
• Every hop crosses an interface boundary, and today those boundaries show seams
• Your job is to design the loop as one product
• That takes real craft across every surface an agent touches — the CLI, the API, MCP, SDKs, Blueprints and Skills, and the documentation that teaches an agent how to operate — plus real craft in web UI, because half the loop is a human deciding whether to trust what an agent just did
• Most designers are strong on one side of that line; we want someone strong on both
• This isn't design following the company's strongest bet; it's design leading it
• We think about agent-native design in three areas: the interfaces agents need to operate, the human ↔ agent handoff where a person supervises and trusts agent work, and trust, safety, and governance — how access is granted, scoped, and revoked
• This role owns all three
• The first two are where the product is moving fastest today, but all three are in scope from day one — the whole point is to design them as one coherent experience rather than three disconnected efforts
• You'll inherit real signal to build on: an AX audit and scoring framework, a developer community that already trusts the product, and a design team treating agent experience as a first-class discipline
• Design the full programmatic interface, not just the CLI
• The agent operates Render through many doors — the CLI, the API, MCP, SDKs, Blueprints, and Skills — and they should feel like one coherent product, not a set of independently evolved tools
• You'll own the interaction model and the error language across all of them, so an agent can run deploy → verify → debug → iterate without a human in the loop
• A one-command path from empty directory to running app matters, but so does an API call an agent can reason about and an MCP surface it can operate reliably
• An error message an agent can't parse and recover from is a broken feature, and you'll treat it that way — on every surface
• Design documentation as an agent-facing product
• Docs aren't just for humans anymore; they're how an agent learns to operate the platform
• You'll design Blueprints, Skills, and reference material that teach an agent to use Render correctly — treating docs-as-experience as a first-class programmatic surface, with the same rigor as any command or endpoint
• Close the human-operated gap in onboarding
• Today the default first-deploy path runs service-by-service through the UI — the one thing an agent fundamentally can't operate
• You'll design a configuration-first path where the whole system is described in code (Blueprints) and deployed in one motion, so the programmatic loop doesn't break at step one
• Design the dashboard surfaces where agent work becomes visible to humans
• When an agent deploys, retries, or fails on someone's behalf, a person needs to see what happened, why, and whether to trust it
• You'll design the review, supervision, and activity surfaces for agent-driven work — web UI held to the same rigor as any flagship flow, because this is where confidence in the whole agent story is won or lost
• Design agent auth and access
• Consent, scoping, and token management — so a developer can grant an agent or third-party app exactly the access it needs, see what that access is being used for, and revoke it without fear
• Least-privilege should feel legible and safe rather than all-or-nothing
• This is half policy design, half interface design, and it's where "can I trust this?" gets answered
• Design one model, expressed everywhere
• The core objects of the platform — applications, services, environments — should mean the same thing whether you meet them in the dashboard, the CLI, the API, an SDK, MCP, or a Blueprint
• You'll design that model once and hold every surface to it, so a human and an agent are always looking at the same product
• Surface the agent-operable paths at moments of intent
• Copy-a-prompt CTAs, post-signup CLI install, post-error tooling suggestions
• The programmatic paths already exist but aren't discovered — you'll place them where developer intent is highest