01The organization
Imagine a 60-person fintech offering card payments to small merchants and short-term loans to their customers. It deploys to production most days. Its platform is a mesh of internal services plus partner APIs for KYC, card processing and credit checks.
There are two QA engineers and no automation team. The regression suite is a mix of manual checks and a few scripts written by a developer who has since left.
This pattern is common in fintech: the product is mostly APIs, the stakes are other people's money, and the team ships faster than its tests. The usual answer, hiring automation engineers, is slow and expensive. The alternative is to let the people who already know the rules write the tests.
02Business objectives
- Test payment and loan journeys on every merge, not once a week
- Cover the compliance edge cases: limits, KYC failures, holds
- Let analysts and product managers write tests
- Keep a record of every run for partners and auditors
03Testing challenges
Cascading changes
A change to the payments service ripples into refunds, payouts and the ledger, and the tests for each live in different places.
Edge cases get skipped
Limit breaches, expired IDs and partial refunds are the cases most likely to be missed under deadline.
API versions move
Partner APIs change versions, and the team finds out when a flow fails in production.
No scripting capacity
Nobody has time to write and maintain code-based tests.
04Before and after
How the testing work would change once the journeys run in Robonito.
- Cadence
- Today:Regression run weekly, while code ships daily.
- With Robonito:The suite runs on every pull request, inside the merge window.
- Authoring
- Today:Tests depend on one developer's scripts.
- With Robonito:Analysts and PMs write tests in plain language; agents maintain them.
- Edge cases
- Today:Limit breaches and KYC failures tested when someone remembers.
- With Robonito:Compliance rules live as named tests that run every time.
- Partners
- Today:Partner API changes discovered in production.
- With Robonito:Chained API tests catch a changed response before release.
05How Robonito would test it
- 1
Generate tests from the specs
AI Studio generates API tests from the OpenAPI definitions and Jira stories; existing Postman collections are imported as they are.
- 2
Chain API and UI
One test calls the payments API, then checks the merchant dashboard shows the same state.
- 3
Write compliance rules in English
Analysts write rules like 'a payout over the daily limit is held' in plain language, and the agent turns them into steps.
- 4
Run on every merge
GitHub Actions triggers the suite on each pull request, with parallel runs and results in Slack.
06Test scenarios, in plain language
Tests you'd write in Robonito on day one. Each one is typed as written; the agent works through the app and saves the steps.
- LendingSubmit a loan application through the API with a credit score of 580 and confirm it is routed to manual review.
- LimitsRequest a payout above the merchant's daily limit and confirm the API returns a limit error and the dashboard shows a hold.
- KYCComplete onboarding with an expired ID document and confirm the portal asks for a new upload.
- RefundsRefund half of a captured payment and confirm the ledger shows the original charge and a partial refund.
- AccessRotate the merchant's API key in the dashboard and confirm calls with the old key are rejected.
- RepaymentsMake an early repayment on a loan and confirm the remaining schedule and interest are recalculated.
07What the pilot measures
No made-up numbers: a pilot measures these against your current baseline, on your own app.
Regression off the critical path
Whether the suite finishes inside the merge window, measured on real pull requests.
Payment-flow coverage
How many money-movement flows are covered, against today's list, with no new hires.
Breaks caught before release
API and flow breaks caught in CI rather than reported by merchants.
Run evidence
Whether partners and auditors accept the run records as they are.
08Rolling it out: the first month
A realistic plan for a team starting from zero, with the baseline comparison built in.
- Week 1
Import what exists
The team imports its Postman collections and OpenAPI specs and generates first API tests in AI Studio.
- Week 2
Add the money paths
Analysts write payment, refund, payout and loan journeys, including the limit and KYC edge cases.
- Week 3
Gate pull requests
GitHub Actions runs the suite on each pull request, with results posted to Slack and failures raised in Jira.
- Week 4
Measure and expand
The team checks run time against the merge window and counts the flows covered against the original list.
09Frequently asked questions
Can Robonito test payment APIs?
Yes. Robonito chains REST API calls into workflows, such as authorize, capture and refund, and can check the result in the web dashboard in the same test. API testing is on the Pro and Custom plans.
Can non-engineers write the tests?
Yes. Tests can be written in plain language, so an analyst can describe a rule like 'a payout over the daily limit is held' and the agent turns it into steps that the team reviews.
Does Robonito run in GitHub Actions?
Yes. Robonito integrates with GitHub Actions, Jenkins, GitLab CI and Azure DevOps, and posts results to Jira and Slack. CI/CD integration is available from the Starter plan up.
How much does Robonito cost for a small fintech team?
The free plan covers web testing with 100 test cases a month. Starter is $20 a month and adds CI/CD, Jira and Slack. Pro is $199 a month and adds API, mobile and desktop testing, 1,000 test cases a month and 5 parallel runs.