Staff Software Engineer, Fullstack /Frontend Focus (Governance)

Build the Future Workforce

Wand turns AI into labor. It enables humans and AI agents to operate together as a unified, hybrid workforce, with comprehensive management and oversight. And it's already operating at scale inside some of the world's largest organizations.

Wand built the world's first Agentic Labor Infrastructure enabling governments and global enterprises to create, manage, and scale digital workforces.

Our mission is to integrate agent ecosystems into the core of work and business, unlocking a generational leap in the global economy. We're building the infrastructure that lets humans and AI agents operate together safely, transparently, and at scale.

Join Wand in leading the Agentic Shift

Wand is building a high-performing global team who take full ownership of what they build. We lead by example, move fast, make data-aware decisions, and continuously push for more, always with a focus on delivering real value to customers.

You would be joining a world-class team that combines deep research expertise and real-world product execution, with experience spanning Deepmind, Google, Amazon, Miro, Elise AI, IBM and Accern.

Position Summary

Governance is one of Wand's core products: the AI and agentic engines that reason over messy, non-deterministic organizational data to catch policy violations, flag risk, and surface what humans actually need to see. As AI agents take on real work inside an organization, someone has to set the rules, run the checks, and make sure everything stays safe and compliant, and governance is how Wand makes that possible at scale. The systems underneath are deep in AI, agents, and knowledge graphs, but governance has almost no dedicated front-end depth right now, and that is the single biggest gap we need to close. All of that intelligence is only as valuable as the surfaces that let a human see it, trust it, and act on it.

We're hiring a frontend-focused full-stack engineer to own the governance product's front-end end to end: turning non-deterministic agent output, risk signals, and complex organizational relationships into interfaces people can actually understand and act on. A big part of this job is deciding what's good and what needs rethinking, then building it. Here you'll get real architectural ownership, not just execution, on a small, remote-first, high-trust, senior-heavy team.

Role Responsibilities

• Own the front-end architecture end to end for the governance product: assess what's been built so far, decide what to keep and what to rethink, then build it.
• Design and build the interfaces where humans review and act on what the governance agents surface: policy violations, compliance risks, and governance findings, often derived from ambiguous, non-deterministic signals.
• Make complex organizational structure and knowledge-graph relationships legible and navigable, so a user can see how a finding connects across the org and why it matters.
• Bring real product and UX sense to inherently complex, high-stakes governance and compliance workflows, not just technical execution.
• Build and maintain the front-end (we lean TypeScript, but we care far more about your track record than an exact stack match).
• Contribute to the backend as needed: understand data structures, APIs, and enough of the knowledge-graph and agent layer to build and reason about the surfaces on top of it. The backend is mainly Go, with Python also in the mix, and we're technology agnostic.
• Take true end-to-end ownership: propose the approach, defend it, then build it, without waiting for someone else to set the direction.
• Build inside a fully AI-driven workflow, using tools like Claude Code as a core part of how you ship, not an occasional assist.
• Partner closely with the AI and backend engineers building the governance engines to turn agent-driven insight into surfaces people rely on.

Key Requirements

• Strong front-end fundamentals: you know the basics cold and can make real architectural calls, not just implement someone else's design.
• Real product and UX sense: good taste, ideally built for real end users on a genuine product, with the judgment to make complex, information-dense workflows feel clear and trustworthy.
• A track record of turning complex or ambiguous data into clear, usable interfaces: dashboards, review and triage flows, visualizations, or similar. A real plus if you've made non-deterministic or probabilistic output legible to people.
• Comfortable across the stack: solid grasp of backend fundamentals (databases, data structures, APIs, general system design), even with front-end as your focus.
• Technology agnostic: you've worked across multiple stacks before and can pick up whatever this team needs. We care about your track record more than your specific stack.
• Genuine ownership: a history of starting things from zero and owning them end to end, not just delivering on initiatives someone else already scoped. You propose the design, defend it, then build it.
• Strong software engineering fundamentals and the independence to thrive in a fast-moving, remote-first, senior-heavy team with very little process.
• Heavy, real fluency with AI coding tools (e.g. Claude Code): you build with AI as a core part of your workflow, not an occasional assist.

Preferred Experience

• Experience building for governance, risk, compliance, security, or other regulated or data-heavy domains, or any product where clarity and trust in the interface genuinely matter.
• Experience visualizing graphs, networks, or relationships (knowledge graphs, org structures, dependency maps, or similar).
• Experience at a startup where you had to build something from scratch with little existing structure to lean on.
• Backend build experience, even if it's not your primary focus. Go is our main backend language, with Python also in the mix.
• Comfortable working fully remote across time zones, ideally with solid overlap with EU hours, on a small, high-caliber team with little hand holding.