There are NO limits to your career: come shape the future and be part of a truly unique global culture at OutSystems!

About the OutSystems Digital Team
-------------------------------------

We are the digital backbone of OutSystems' growth — building the enterprise applications, integrations, and AI agents that accelerate the company into the AI-powered era. We work in small, high-autonomy teams of two to five people, each with full AI tooling, a clear mission, and the authority to ship. We take both craft and speed seriously, and we expect the people who join us to do the same.

About the Role
------------------

You will join an existing team and take technical ownership of a portfolio of live products and SaaS, while leading the delivery of new capabilities that solve the organisation's most important problems.

This is not a role for someone who ships things and moves on. You are responsible for the quality of what is already running and the correctness of everything new that gets built. Those two things are not in tension — the same standard of judgment that protects live systems is what makes new systems worth building.

Most of your energy — roughly seventy percent — will go into innovation: new agents, new integrations, new capabilities that did not exist before. The remaining thirty percent keeps the existing portfolio healthy, coherent, and evolving. That balance is a principle, not a ceiling: when a live system needs attention, it gets it.

What You Will Own
---------------------

• The quality bar for everything the team ships — new features and live systems alike. You define the architectural principles the team works against, and you are the final call on production readiness.
• Technical direction of a small, high-autonomy team — not through process and approvals, but through a clear standard of correctness that everyone can verify their work against.
• AI agent orchestration — directing tools like Claude Code, OutSystems Mentor, and Cursor toward specific outcomes; knowing when to trust their output and when to reject it.
• Context design for your domain — ensuring AI agents have the enterprise context they need to produce correct, compliant output without repeated clarification.
• Portfolio integrity — understanding the existing applications well enough to extend them without accumulating hidden debt, and well enough to know when something needs to be rebuilt rather than patched.
• Fast validation of new approaches — when there is uncertainty about a technology, a model, or an architecture, you explore quickly and return with a clear recommendation rather than committing the team to an untested path.

The Behaviors We Are Looking For
------------------------------------

You have reached the level of system-level judgment where you can direct AI agents toward correct output without reading every line they produce. Here is what that looks like in practice:

• You evaluate at the system level . Your first question about any piece of work is not 'does it run?' but 'is it right?' — architecturally, strategically, and in the context of everything else the team maintains.
• You distinguish correct from plausible. AI output that looks right is not the same as AI output that is right. You catch the difference before it ships, not after it compounds into something expensive to fix.
• You specify before you build. You translate a vague business problem into a specification precise enough that an AI agent — or a junior developer — can execute without follow-up. This is a thinking skill, not a writing one.
• You default to experimentation over alignment. Faced with uncertainty, you run a fast test and return with evidence. You do not schedule a workshop to agree on a path when a working prototype can answer the question in a day.
• You hold the shared mental model . In a small team, the architectural vision is the immune system of the product. You maintain it actively — in documentation, in code reviews, in the feedback you give.
• You are direct about what is wrong. You tell people when an approach is incorrect, and you explain why in three sentences. You do not soften correctness into ambiguity to avoid discomfort.
• You respect what is already running. You understand that live systems have users who depend on them. You extend them with the same care you would apply to anything new — which means you understand them before you change them.

Experience
--------------

• 5+ years of hands-on development, with at least 2 years leading technical delivery
• Demonstrated experience with AI-augmented development — Claude Code, Cursor, GitHub Copilot, or similar — used in production, not in experiments
• Track record of shipping production-grade systems and maintaining them over time
• Strong architectural instincts across integration, data, and application layers
• Fluency in context engineering: specifying problems so completely that agents can execute without repeated clarification

Bonus
---------

• Proficiency with OutSystems ODC
• Experience with MCP (Model Context Protocol) server creation and integration
• Experience integrating LLMs via API into enterprise applications
• Background in regulated industries — finance, healthcare, insurance — where governance and correctness matter beyond preference
• Prior experience in small, high-autonomy teams where every person's judgment is tested daily

This Is Not For You If...