Staff Software Engineer, Product Surfaces

You own a meaningful part of Tactiq’s product.

You take incomplete product direction and turn it into something real: make the missing product and technical decisions, build the first comprehensive version, get it into production, learn from what happens, and keep owning it as it grows.

Your initial area could be our MCP and AI-assistant experience, native desktop/mobile apps, AI Dictation, or another important product surface. We care more about finding the right person than matching someone to a narrowly predefined charter.

Product might give you a direction, an opportunity, or a rough prototype. They will not give you a detailed specification covering every state, integration and edge case.

That's part of your job.

You should naturally notice the surrounding product system: onboarding, permissions, failure states, analytics, rollout, observability, billing, supportability and how we'll know whether it worked.

Then you build it.

This is a deeply hands-on role. We expect you to ship substantial product areas through your own judgement, engineering ability and effective use of agents. You don't need a team assigned underneath you to have significant impact.

And once something ships, it remains yours. You own its production behaviour, improve it, discover opportunities within it and make it easier for agents and other engineers to contribute safely.

Over time, you should also make your area require less continuous human attention: recurring investigation, implementation, testing and operational work should increasingly become part of the system itself.

• Own a product area end-to-end: users, architecture, metrics, economics, failure modes and production behaviour.

• Turn intent into product: independently close the many decisions between a product direction and something users can rely on.

• Shape the what as well as the how: discover problems and opportunities within your area instead of waiting for them to be enumerated.

• Build across boundaries: frontend, backend, APIs, data, infrastructure, native clients, AI systems or third-party platforms - wherever the outcome takes you.

• Use agents as execution capacity: delegate implementation, investigation and testing aggressively while retaining responsibility for judgement and results.

• Increase safe autonomy: improve context, tooling, evals, observability and guardrails so more useful work can happen without constant human supervision.

• Own production: measure what happens, investigate failures and iterate based on evidence.

• Finish things: reduce ambiguity, resist unnecessary scope expansion and get useful results into users' hands.

We're not looking for someone who needs the problem boundary supplied to them.

Given incomplete intent, you can work out what actually needs to be solved and make sensible decisions across product and technical concerns.

And success isn't simply doing more work personally. As your area matures, routine work should increasingly stop requiring your attention.

Your leverage should grow over time.

• Strong evidence of owning important user-facing products or product areas end-to-end.

• A history of turning ambiguous or incomplete ideas into production systems.

• Strong product judgement and the ability to make decisions without continuous specification or approval.

• Broad technical judgement across system boundaries, with the ability to go deep where needed.

• Strong modern software engineering fundamentals and production debugging ability.

• Substantial hands-on use of AI coding agents as part of normal development.

• Familiarity with modern AI application patterns such as tool calling, MCP, agents, evals, context and permissions.

• Evidence that you've created leverage around yourself through automation, tooling, observability or systems that eliminated recurring manual work.

• The ability to learn unfamiliar domains quickly.

• You want work to arrive as well-defined tickets.

• You primarily want to advise on architecture while others build.

• You consider the job finished when the code merges.

• You need a team underneath you before you can have substantial impact.

• You love prototypes but lose interest in production ownership.

• You prefer staying inside a narrow technical speciality.

Under the hood, a TypeScript monorepo: Node.js/GraphQL with Temporal, Firebase, Elasticsearch, React, a Chromium extension, native macOS and Windows apps, and an increasing number of AI and agent-driven systems.

We ship in small, reversible changes, often many times a day. Tests, evals, observability, feature controls and automated review help us move quickly without outsourcing engineering judgement.

We use Linear, Mixpanel, Datadog, Claude Code, Cursor and whatever else earns its place.

We're also deliberately moving important context out of individual heads and into code, documentation, skills, telemetry, evals and explicit constraints so both humans and agents can work effectively across the system.

We handle sensitive meeting data, so privacy, permissions, access control and safe AI behaviour are first-class product requirements.

• In your first month, you're productive enough in the product and codebase to ship useful production changes safely.

• Within three months, you've taken a materially ambiguous problem from product shaping through implementation, rollout and observation without requiring detailed specification.

• Within six months, there is an important product area that is clearly yours. You're independently discovering and closing important problems within it.

• Over time, that area becomes increasingly self-observing and easier to operate. Routine problems require less manual attention, agents can safely make more progress, and your time shifts toward novel opportunities and difficult judgement calls.

One path is to expand your technical and product scope: identify new problem spaces, establish new product surfaces and govern a larger part of the product.

An alternative path is to expand through people and organisational capability: develop exceptional engineers, identify capability gaps, hire great people and increase the leverage of the engineering organisation.

Neither path requires giving up being technical.

• Timing: AI meeting intelligence is a category still being defined, and we're one of the ones defining it.

• Scale: a business that works, aimed at the next milestone of $100M ARR, with a PLG motion that grows itself reinforced with PLS and a lot still ahead.

• Leverage: a small, AI-enabled team, so one engineer's work goes a long way.

• Equity & impact: your work is visible, and you have equity in what you build.

• Flexibility: autonomy-first and flexible about how you work, with at least a half-day overlap with Sydney time (you're first-line for your own regressions).

• Modern tooling: Linear, Mixpanel, Datadog, Claude Code, Cursor, and whatever else earns its place.

A first conversation; a one-hour deep dive on system design and past work; and a one-hour paired session on our real codebase, AI tools welcome (not a whiteboard puzzle). We aim to go from first call to offer in about two weeks, and keep the process useful on both sides.

If you don't tick every box but think you're a strong fit, apply anyway - we'd rather meet you and figure it out.

Send us at engineering2026 at tactiq io a brief note covering:

1. Why Tactiq?

2. Tell us about a product or product area you owned end-to-end. What were you originally given, and what important things did you have to discover or decide yourself?

3. What happened after it shipped? How did you know whether it worked, and what did you change as a result?

4. Tell us about something you made substantially less dependent on human effort.

#LI-DNI