AinoAid: Scaling a Trusted Multilingual Support Service with Agentic Software Development
How We Encourage turns complex, sensitive requirements into a growing digital service across countries and languages, while AI coding agents accelerate delivery and people retain control.
At a Glance
The service: Awarded by the European Commission, an anonymous, multilingual digital support service for people affected by interpersonal violence, their close ones and the professionals who support them.
The experience: Conversational guidance, a structured knowledge base, content search and voice interaction in one accessible service.
The reach: Live in six countries and seven languages, with further expansion underway.
The delivery model: Business requirements are translated into detailed technical stories, then implemented largely by AI coding agents under continuous human direction, review and approval.
The business value: A repeatable way to expand the service faster while protecting quality, consistency, traceability and human accountability.
Making Support Easier to Find
For someone experiencing interpersonal violence, understanding and accepting that they are subject to violence, finding reliable information and deciding what to do next can be difficult. Relevant services may be fragmented across organisations, terminology can be unfamiliar, and asking for help may feel unsafe or overwhelming. Friends, family members and professionals can face the same uncertainty when trying to support someone effectively.
AinoAid™ was created to make that first step easier.
The service brings together an AI-powered chatbot, a structured knowledge base, practical guidance and links to relevant support. Users can explore information and ask questions in natural language, via text or voice, without disclosing their identity. AinoAid does not attempt to replace professional help. Instead, it helps people understand their situation, identify possible next steps and find appropriate services.
The service has been shaped by international projects, incorporating input from survivors and professionals and drawing on expertise from research, social services, healthcare, victim support, and law enforcement. That foundation matters: in a sensitive domain, useful technology must be built around real user needs, credible information and safety-conscious service design.
Today, AinoAid is available in six countries and seven languages, and the chatbot can be used with over 100 languages. Expanding a service like this is not simply a matter of translating an interface. Every new market introduces different terminology, service structures, content requirements, user journeys and operational needs. The platform therefore has to evolve quickly without losing consistency or maintainability.
That challenge led We Encourage to adopt a different kind of engineering model.
The Challenge: Scale Without Losing Control
AinoAid combines several demanding product characteristics:
It operates in a sensitive domain where accuracy, clarity and safety matter.
It serves several audiences, including people directly affected by violence, their close ones and professionals.
It must work consistently across countries and languages.
Its content, user experience and support pathways need to evolve as new research, partnerships and market requirements emerge.
It uses conversational AI and speech capabilities while still requiring clear human accountability for what the service does.
A conventional delivery process can struggle under this combination. More markets create more variation, which in turn creates more documentation, testing, and coordination. Over time, the distance between a business requirement and the code that implements it can become difficult to see.
We Encourage needed an engineering process that could increase delivery capacity without weakening product judgement or governance.
The Solution: A Story-Driven, Agentic Delivery Model
The AinoAid engineering process begins with a simple principle: agents may accelerate implementation, but people remain responsible for intent, priorities and outcomes, at every step.
Business Needs Begin as GitLab Work Items
Every significant change starts as a business requirement in GitLab. It may describe a new feature, a content capability, a market-specific need, an improvement to the user journey or a technical change required to support future growth.
Starting with the business requirement keeps development connected to its purpose. The team can trace a production feature back to its original need rather than managing a disconnected collection of technical tasks.
Detailed Stories Turn Intent into Executable Specifications
Business requirements are refined into a structured library of more than 100 detailed technical stories. Each story explains what must be built, why it is needed, how it should behave and how the result will be verified.
These stories are more than backlog items. Together, they form an executable body of product and engineering knowledge:
Product decisions become explicit rather than remaining in conversations.
Agents receive enough context to implement complete features rather than isolated code fragments.
Reviewers have a clear definition against which to validate the result.
The relationship among requirements, implementation, tests, and documentation remains evident.
The story library grows into a living account of how the platform works and why it was designed that way.
For agentic development, this level of specification is essential. The quality of the implementation depends heavily on the quality of the intent given to the agent.
AI Coding Agents Perform Most of the Implementation
Once a story is ready, AI coding agents carry out a large share of the implementation work. They can inspect the existing codebase, make coordinated changes across the frontend and backend, add tests, update documentation and respond to review feedback.
This changes where the team spends its time. Less effort is consumed by routine code production, and more can be directed towards the work that has the greatest effect on the product:
understanding user and market needs;
making product and design decisions;
defining precise acceptance criteria;
reviewing architectural choices;
validating behaviour in realistic situations;
assessing safety, security and quality;
deciding what is ready to ship.
The agents increase implementation capacity. They do not replace ownership.
Human Direction and Approval Remain Built In
AinoAid is not developed by giving an autonomous system a vague objective and accepting whatever it produces. Human decision points remain throughout the process, from planning to approval.
People decide what should be built, what matters most and what trade-offs are acceptable. They shape the user experience, review the implementation, challenge incorrect assumptions and approve meaningful changes. They also remain accountable for the correctness, security and quality of the production service.
This division of labour is central to the model: agents provide speed and breadth; people provide context, judgement and responsibility.
Automated Delivery Turns Approved Work into Production Software
Approved changes move through a fully automated GitLab CI/CD pipeline. Builds, automated tests and deployments follow the same repeatable path for every change.
This reduces manual handovers and makes releases more predictable. It also shortens the path from an approved requirement to a production improvement. When a change has passed review and verification, the delivery machinery is already in place to release it reliably.
“AinoAid operates in a field where trust and quality cannot be compromised. Our agentic development model helps us move faster, but the important decisions remain with people and their expertise. We define the need, guide the work and take responsibility for what reaches our users.”
-- Anna Juusela, CEO, We Encourage
Business Impact
The value of the model lies not merely in the fact that code can be written faster. It creates a more scalable way to operate the product.
A Faster Route from Requirement to Release
Detailed stories give agents the context needed to perform substantial implementation work, while automated testing and deployment reduce delays after the code is complete. The team can move from a defined business need to a validated production change with fewer manual steps.
A Repeatable Foundation for New Markets
Expansion still requires local expertise and careful content work, but the underlying product process is reusable. Market-specific requirements can enter the same story system, use the same design patterns and pass through the same quality controls. This helps the platform grow without each country becoming a separate software product.
Quality Controls That Scale with Delivery Speed
Agent-written code is not treated as inherently correct. Unit tests, end-to-end tests, human review and explicit acceptance criteria are part of the normal flow. Quality is built into the process rather than added after implementation.
Better Traceability and Less Knowledge Loss
Requirements, stories, code, tests and generated technical documentation reinforce one another. This makes the system easier to understand, review and maintain as both the platform and the team evolve.
More Human Attention for the Work That Needs It Most
In a service built around vulnerable and hard-to-reach users, empathy, domain expertise and product judgement are irreplaceable. By reducing the effort devoted to mechanical implementation, the model allows more attention to be devoted to those distinctly human responsibilities.
“For us, the real advantage is not simply producing code more quickly. It is being able to turn what we learn from users, professionals and new markets into expanded knowledge and a better service quickly.”
-- Anna Juusela, CEO, We Encourage
The Technology Behind the Model
The technology stack supports the operating model rather than defining it. Each part has a clear role in helping the team deliver a consistent, maintainable and scalable service.
GitLab Work Items, Runners and CI/CD
GitLab provides the continuous path from requirement to deployment. Work Items capture business needs; stories organise implementation; runners execute the delivery workflow; and CI/CD automates builds, tests, and deployments. Keeping this flow within a single environment improves traceability and reduces manual coordination.
Next.js and TypeScript Frontend
The frontend is built with Next.js and TypeScript. This provides a modern foundation for a responsive multilingual experience, while type safety helps identify defects before they reach users.
.NET and C# Backend
The backend uses .NET and C# for business logic, integrations and conversational orchestration. The platform provides a mature, strongly typed foundation for a service that must remain reliable as its functionality and geographic reach increase.
Figma and Storybook Design System
Figma and Storybook provide a shared design language for both human contributors and coding agents. Reusable components and documented interaction patterns help protect usability and brand consistency across features, languages and markets.
Azure AI Foundry
Azure AI Foundry supports the conversational and speech capabilities at the centre of the service. It provides the team with an enterprise-grade platform for integrating language models and voice interaction into the broader AinoAid experience.
Vitest and Playwright Test Automation
Vitest unit tests and Playwright end-to-end tests provide automated checks at different levels of the system. These tests are especially important in an agentic workflow: they give rapid feedback, catch regressions and provide objective evidence that an implementation behaves as intended.
Automatically Maintained Technical Documentation
The same story-driven process also produces and updates technical documentation for individual features and the architecture as a whole. Keeping documentation close to implementation reduces knowledge gaps and makes future changes safer and easier.
Together, these technologies give a relatively lean organisation the engineering structure needed to manage a sophisticated product across several markets — without creating an equally large layer of manual process around it.
What This Project Demonstrates
AinoAid shows that agentic software development can be more than an experiment or a coding shortcut. With strong specifications, deliberate human oversight, automated verification, and a disciplined delivery pipeline, it can serve as a practical operating model for a real production service.
The central lesson is not that people can be removed from software development. It is almost the opposite: when agents take on more of the implementation work, human clarity and judgement become even more valuable.
For We Encourage, this model creates the capacity to keep improving AinoAid, respond to new knowledge and partnerships, and bring the service to more people in more languages — while preserving the trust, quality and accountability the mission demands.
