Associate Technical Architect

While technology is the heart of our business, a global and diverse culture is the heart of our success. We love our people and we take pride in catering them to a culture built on transparency, diversity, integrity, learning and growth.
If working in an environment that encourages you to innovate and excel, not just in professional but personal life, interests you- you would enjoy your career with Quantiphi!

We are looking for a Associate Architect SD who has led a team and who uses generative AI heavily to deliver day-to-day engineering work.

This is a builder's role with an architect's habits. You will own problems from the vague first description through to something running in production, and you will do it by directing AI rather than by typing every line yourself. You will work closely with the Tech Architect as a thinking partner across product and engineering.

This is the part we will not compromise on. You should be able to point to real delivery, not experiments or weekend reading.

• Spec-driven development. You have worked from a written spec that an agent executes against. Frameworks such as GSD, BMAD or SpecKit, or an equivalent approach your team built in-house.

• Harness engineering. Hands-on with an agent harness such as Claude Code, Kiro or GitHub Copilot. You have configured and shaped one, not only typed into it.

• Sub-agents. You understand how to split work across agents, and where that helps and where it makes things worse.

• Skills and custom agents. You have built reusable skills or custom agents for your own workflow rather than using only what came out of the box.

• Judgment about all of the above. You know where these methods break down, because you have hit it.

Good to have, and worth telling us about: context and token efficiency, evaluating agent output at scale, cost control, or your own tooling built on top of a harness. This field moves faster than any list we can write, so if you have gone further than the bullets above, say where.

We care about range more than depth in any single technology.

• Comfortable across layers: frontend behaviour, backend services and API design, and how data is modelled and stored.

• React, TypeScript, Node, Python, relational and document databases are the kind of ground we work on. You should be able to operate on most of it.

• Able to hold an architecture discussion and design a system, rather than recall framework specifics.

• Hands-on with a major cloud provider, AWS or GCP.

• Comfortable with Docker.

• Able to set up CI/CD pipelines for automated testing and deployment.

• Familiar with logging and observability tooling.

All three are required. If you do not meet all three, this is not the right role for you right now.

At least five years building software professionally.

You have led a team. Formal reports or a tech lead role with no reporting line both count. What matters is that you have actually led, not what the title said.

You have worked across layers, not inside one. We are not looking for a specialist in a single part of the stack.

Take a problem from first description to delivered feature. Turn vague requirements into a technical plan, and surface risks and trade-offs while they are still cheap to act on.

You drive that delivery with generative AI. Spec-driven development and agent harnesses are how the work gets done here, not a side experiment.

Hold the architecture in your head: how the frontend, the services and the data layer fit together, and where each will strain.

You need that so you can work with an agent to reach the right design, review what it proposes, and catch the choice that will hurt in six months. You are not expected to hand-build every layer yourself.

You have built real software before, and it shows in the questions you ask. An agent will happily produce code that works on a clean slate, and most of our work is not a clean slate. Reading an existing system, understanding why it is shaped the way it is, and changing it without breaking things is the job.

You should also be able to tell where AI genuinely belongs in a product and where it does not, with a working sense of the cost, latency and failure modes involved.

You set the standard for what ships. When most of the code is agent-written, the skill is not typing it cleanly. It is knowing what good looks like and catching what is wrong in review.

You work closely with the Tech Architect, product managers and other engineers. You raise blockers early and bring options with them.

Be ready to walk us through one feature you shipped where an agent wrote most of the code: what you specified up front, what came back wrong, and what you had to fix yourself. 

Link a pull request or repository if the work is public. Most of this work sits behind a company firewall, and that counts against you not at all.

This is not a traditional full-stack engineering job, and the difference is not cosmetic.

The engineers who do well here think in user journeys, systems and outcomes rather than tickets. They own problems rather than tasks. And they treat AI as the way the work gets done, not as a tool they occasionally reach for.

If that describes how you already work, this will feel like the obvious next role. If it does not, it will be a frustrating one.