LUCENTIVE

Systems · Open role

Build the screens and tools people use on top of the AI system.

You build the product surfaces that make IAS usable: review queues, approval flows, dashboards, and admin tools a reviewer or client actually touches. The work runs end to end on the typed Next.js and Convex stack, from schema decision to shipped screen.

Remote · EU-based · CET overlap · Contract or full-time

Mission

What the role does and why it matters here.

The Senior Product Engineer builds the product surfaces that make IAS usable: the review queues, approval flows, dashboards, and admin tools that sit on top of the agent runtime and the audit trail. Where the Context Architect defines the structure and the AI Systems Engineer builds the runtime underneath it, you build the screens and workflows a reviewer, an operator, or a client actually touches. You own a feature from the schema decision through the shipped surface, across both the shared IAS codebase and engagement-specific repos. The same typed stack underlies work across Lucentive, so what you ship here does not stay local by accident. You are expected to notice when a pattern generalizes and to build it that way the first time, not after the second team asks for it.

Responsibilities

What you would own.

Own features end to end

Own features end to end: data model in Convex, business logic, shipped UI, without waiting for a fully specified handoff.

Build the product surfaces

Build the product surfaces on top of the agent runtime and the audit trail: review queues, approval flows, dashboards that make an agent's work legible to a human reviewer.

Maintain the typed contract

Maintain the typed contract between the Convex backend and the Next.js frontend, so a schema change surfaces as a compile error before it becomes a production surprise.

Ship across codebases

Ship across both engagement-specific and shared codebases, and build features that generalize past the first client rather than fork with each one.

Turn contracts into screens

Pair with the AI Systems Engineer and the Context Architect to turn a runtime contract or a validator spec into a shipped screen.

Keep it fast and legible

Keep the product fast and legible under real usage, not just correct in the demo.

Instrument what you ship

Instrument what you ship so the team can see how a feature behaves after it lands, not only whether it compiled.

How you think and work

Six traits the work demands.

Pedigree isn't the filter. Disposition is. The six traits below are what the work actually asks of you.

  1. Agentic intuition

    You read agents the way a manager reads a direct report: when to trust the output, when to interrupt the run, when to take the wheel back.

    You've built the UI that tells a reviewer when to trust an agent's output and when to look closer, before the agent's mistake became the user's problem.

  2. Critical thinking

    Confident-sounding output gets the same scrutiny as anything else, your own work included.

    You've pushed back on a feature request and shipped the smaller, correct version instead.

  3. Curiosity

    You pull on threads. You read outside the lane. You follow a question past the first plausible answer.

    You'd rather trace a bug through the Convex function that produced it than patch the symptom in the UI.

  4. Agency

    You move without being told. You decide, ship, own the call. No one has to write the playbook for you.

    You've shipped the feature the ticket didn't fully describe because the gap was obvious once you started building.

  5. Systems thinking, long view

    You see how the parts connect, and where this goes in three years.

    You design the component knowing the next feature, not just this one, will be built on top of it.

  6. Leadership instinct

    You orchestrate work across humans, agents, and stakeholders. You switch register between a workspace ticket, an architect call, and a senior bank room in the same day without losing what you came in to say.

    You've explained why a shortcut would cost the team later, and the team took the longer road.

Useful background

  • Senior experience shipping product end to end in production: schema, backend, and frontend, not a portfolio project.
  • Next.js and Convex, or an equivalent typed end-to-end stack in TypeScript; we read for the discipline, not this exact framework pairing.
  • Comfort owning ambiguity: given a rough workflow, you can turn it into a working feature without a fully spec'd ticket.
  • Practiced at reading someone else's schema and runtime contract and building on top of it without breaking it.
  • You can move between engagement-specific repos and a shared core codebase without losing track of what belongs where.
  • You've built product surfaces on top of an AI or agent backend: review queues, approval UIs, audit trail viewers, or similar.
  • You've worked in a small team where the person who designed the schema and the person who shipped the button were the same person, the same day.
  • You've shipped into a regulated or safety-relevant setting where a broken feature had a real cost.
  • You've contributed a pattern, a component, or a data shape that another team picked up and reused without you in the room.

Regulated-industry experience isn't required. Curiosity about it is.

Logistics

How the role is set up.

Location
Remote. EU-based team, with at least four hours of overlap with CET on a working day; Portugal hub.
Engagement
Contract or full-time.
Start
Flexible, coordinated at offer stage.
Language
English, the working language for engineering and review.

Apply

We look forward to hearing from you.

Apply for Senior Product Engineer