Inside Enterprise FinTech: What 100% Kiro Adoption Delivered Across Six Engineering Teams

Project snapshot

Our client is a US-based enterprise FinTech platform operating in the benefits management space and run by six delivery teams — Core, Banking, RegTech, Integration, AI, and Mobile/Frontend.

Over the 2025 to 2026 period, Intellias rolled out Kiro (AWS’s agentic AI assistant) to 100% adoption across every team (50+ people). It enabled the teams to transition to a “Spec-first” AI development approach to produce two distinct wins: a gain in engineering throughput and quality, and a second gain in business analysis delivery — the same agent, shaped by the same team standards, paying off twice along the delivery lifecycle.

Challenge: A complex FinTech estate where delivery capacity is the constraint

The client’s platform spans multiple channels: web portals, mobile apps, admin interfaces, and partner API integrations. They are backed by hundreds of endpoints across multiple microservices, with strict business rules and a regulated operating environment. In that setting, capacity is the constraint at two points in the lifecycle:

• Engineering throughput. Senior engineers spend significant time on mechanical work: writing unit and integration tests, migrating long-running workflows off legacy Temporal, upgrading runtimes (Java 21, AWS SDK), and optimizing queries — all before new product work even starts.
• Test and quality overhead. Regression confidence depends on test coverage that is slow to write by hand, and a class of production incidents kept recurring from the same database-level root causes.
• Business analysis overhead. Every feature requires Functional Requirements on Confluence; Epics, User Stories, and Frontend Tasks in Jira with structured Acceptance Criteria, endpoint references, and design links; technical investigation across the API surface; and refinement preparation pulling context from Confluence, Jira, Figma, and the codebase. A single User Story took roughly an hour to research, draft, and format.

The cost is cumulative across six teams and every sprint. The question we set out to answer was practical: can one agent, shaped by the teams’ own standards and wired into their own tools, meaningfully lift capacity — first in engineering, then in analysis — without compromising quality or control?

Approach: AI as an accelerator across the lifecycle, not a replacement

The goal was never to replace engineering or business analyst (BA) judgment. It was to compress the mechanical parts of the work (test writing, migration scaffolding, research, drafting, formatting, searching) so the people spend more time on design, analysis, and decisions, and less on assembly. Two conditions guided the rollout, and they held for both use cases:

• Shape the AI with the team’s own standards. Kiro uses the teams’ actual templates, writing-style rules, architectural patterns, and documentation structure — not generic output that needs reformatting.
• Keep humans in the loop. Every output requires validation, domain context, and critical thinking that only the engineer or analyst holds.

We led with engineering — the largest population and the clearest throughput constraint — and then extended the same setup to business analysis as a second gain.

Primary use case: Engineering performance across six teams

How the teams use Kiro

With Kiro at 100% adoption, the engineering teams use it for the mechanical core of day-to-day delivery:

• Test writing. Generating unit and integration tests against existing code, raising coverage faster than hand-writing allows.
• Workflow migration. Redesigning long-running workflows off the old Temporal implementation, and moving contribution, transaction-hold, enrollment, and settlement workflows onto the new transaction model.
• Runtime and dependency upgrades. Java 21 migration and AWS SDK upgrades across services.
• Optimization and hardening. Query optimization against RDS, contract-test (PACT) proofs of concept, and consistent linting across Kotlin aggregators.
• Incident root-cause analysis. Tracing recurring production incidents to their database-level root causes and eliminating them.

The agent does the scaffolding and the first pass; the engineer reviews, corrects, and owns the result.

Outcomes: Engineering

Measured 2025 → 2026 after full Kiro rollout. Velocity and unit-test figures from Jira / Kiro usage reports; production incidents from monitoring data; remaining figures are team estimates.

Velocity growth by team

* Banking had one additional developer in the baseline period.

Against the industry benchmark. AI-assisted development benchmarks for 2025–2026 (DX Research, Jellyfish, GitHub Octoverse, METR) put average velocity growth at +10–30%, top fintechs near +30%, and time saved around 4 hrs/dev/week. The client sits at benchmark on average (+15.6%) and above it on Frontend (+31.4%), on track for time saved (~3.5 hrs), with confirmed test-speed and incident-reduction gains — all at 100% adoption versus an industry norm closer to 51% daily use.

Second gain: Business analysis acceleration

The same agent, the same “shape it with our standards, keep humans in the loop” model, applied to the BA workflow produced the second win: compressing the documentation, ticketing, and investigation overhead that sits in front of every feature.

How it is set up

The BA configuration is maintained as a shared Git repository (Kiro-commons) that any analyst pulls and applies via symlinks — one git pull updates everyone, with no per-person customization. It carries three things:

• MCP integrations — Kiro connects to Jira and Confluence (create/update/search issues and pages, transitions, sprints) and Figma (read designs, extract component structures, download images), authenticated via API tokens injected as environment variables.
• Steering files — persistent behavioral rules loaded into every session: the domain model, the BA thinking model (Why → Who → What → How → What if → Metrics), exact templates for Epics/User Stories/Frontend Tasks/Spikes, requirements-writing rules, FR document structure, API-documentation format, and communication style.
• Skills — reusable multi-step workflows triggered on demand: writing-epics, writing-user-stories, writing-frontend-tasks, writing-functional-requirements, writing-acceptance-criteria, process-decomposition, requirement-gap-detection, root-cause-analysis, stakeholder-questions, find-feature-content, and API-gateway-explorer.

A standout is the API Gateway skill, which queries the live OpenAPI spec to index every endpoint and resolve full request/response schemas. This lets a BA independently investigate existing API behavior and put accurate endpoint references into Frontend Tasks without waiting for developer availability. New analysts onboarding takes under 10 minutes.

Where it helps most

• Documentation and tickets: generates Epics, User Stories, Spikes, and Tasks from Functional Requirements; writes Acceptance Criteria covering happy path, edge cases, and negative scenarios; summarizes Confluence into Jira tickets; produces Confluence pages from team templates.
• UI / frontend features: describes UI flows from Figma, creates frontend tasks with HTTP method + URL references, and suggests payload/response shapes from existing API specs.
• Technical support for BAs: analyzes existing functionality and speeds up bug investigation without a developer in the loop and generates elicitation questions for discovery and refinement.

Outcomes: Business analysis

Feedback from the team:

Where we’re focusing next

Both use cases point to the same frontier and we’re already building toward it:

• Introducing a semantic layer across our microservices, so Kiro can reason for complex backend workflows that span multiple services.
• Expanding steering files and domain knowledge bases to encode the deep business logic our teams have built over the years.
• Indexing cross-system integrations so dependencies that are undocumented today become visible and traceable to the agent.
• Capturing tribal knowledge into reusable skills and steering files, turning what lives in people’s heads into shared, durable context.

As each of these initiatives lands, Kiro’s context keeps compounding — every new steering file, skill, or knowledge base expands what the agent can safely take on. Human validation, system understanding, and domain context stay with the engineer and the analyst; that ownership is what keeps the gains real.

Clear outcomes for our client at scale

The rollout answered the practical question: one agent, shaped by the teams’ own standards and connected to their own tools, meaningfully lifts capacity at two points in the delivery lifecycle — +15.6% engineering velocity (Frontend +31.4%) and 3–5× faster structured BA documentation — without changing who owns the decisions.

The architecture is what makes it scale: shared Git configuration, symlinked steering and skills, MCP integrations into Jira, Confluence, and Figma. One git pull updates every team, and each new skill or indexed knowledge base compounds the gain. For a regulated fintech estate with six teams, multiple channels, and hundreds of endpoints, that compression is the difference between capacity spent assembling artifacts and capacity spent building the next product.

What comes next

Intellias and AWS

Intellias has a longstanding partnership with AWS, holding the Financial Services Industry (FSI) competency and the Generative AI competency, alongside multiple other AWS competencies across our practice. That relationship gives our teams early access to AWS’s newest capabilities and direct routes to AWS specialists when engagements call for it, so clients get proven, production-tested practices rather than day-one experimentation.