Our approach

From the business question to a working solution.

We run every project in six stages, scaled to its size. Each one produces a result you can check and ends with a decision that's yours to take. So at any point you know where the project stands and what we need from your teams.

Before anything is built, we set the frame with you.

  • The problem to solve and the scopewith the constraints to respect
  • What will count as useful progress
  • Your business owner
  • Your technical contactif the project touches your systems
  • The access we needand the decisions that require your approval
  • How often we meetand who attends

When an important piece of information is missing, we say so and suggest how to get it, because a scope built on an unchecked assumption tends to move later.

Six stages, a result at each one.

These stages describe how we usually work. Depending on the project, some are shorter or combined, and we go back to an earlier stage when a test calls for it.

  1. Stage 01

    Understand the situation

    It starts with how things work today, which we look at with the people who do the work, across its steps, tools, data and constraints. Then we write down the problem as we understand it.

    Result
    a written problem statement and an initial assessment.
    Decision
    what the project must solve, and what still needs looking into.
    Your part
    describe how the work really happens, provide sample documents or data, name an owner.
  2. Stage 02

    Prioritise and set the scope

    We compare the options by usefulness, feasibility, dependencies and risk. The most useful ones form a first scope, in order, and the investment is set on that scope. We only suggest a pilot when it settles a real doubt.

    Result
    priorities, the agreed scope, acceptance criteria and the order of work.
    Decision
    what goes ahead now, and what waits.
    Your part
    make the trade-offs, confirm the constraints and how the result will be signed off.
  3. Stage 03

    Design and validate

    Screens, workflow, technical architecture and control rules are described before anything is built, then our assumptions are tested on mock-ups, a prototype or samples of your data. For an AI project, we also prepare the evaluation scenarios, the data the system may use and the points where a person approves.

    Result
    mock-ups, the architecture diagram and, for AI, the evaluation scenarios.
    Decision
    the go-ahead to build.
    Your part
    review the mock-ups against real cases and confirm the constraints.
  4. Stage 04

    Build, integrate and test

    Development happens in an environment separate from production, then we connect what was built to your systems. Each part is tested on representative situations against the acceptance criteria, and every issue found is logged with its fix.

    Result
    working features, live connections and a log of the issues fixed.
    Decision
    go-live, once the criteria are met.
    Your part
    provide access, test with your teams and flag anything that doesn't match how you work.
  5. Stage 05

    Deploy and support adoption

    Go-live is prepared with you, including any data migration that's needed, user guides and training for the teams involved. Then we follow the first weeks of use, because that's when the real adjustments show up.

    Result
    the go-live plan, guides, documentation and the list of owners on each side.
    Decision
    live use, and what each side remains responsible for.
    Your part
    approve the rollout, name your internal owners and bring the users on board.
  6. Stage 06

    Measure and improve

    We review the measures agreed at the start, actual usage, user feedback and incidents. That review produces a list of improvements ranked by usefulness, and what happens next is your choice.

    Result
    a written review and a ranked list of improvements.
    Decision
    adjust, extend or close the project.
    Your part
    share what you've observed and approve any new scope.

Who works on your project.

Every project has an owner on our side, who carries the scope and the decisions with your business owner. Our engineers build the system and connect it to your tools, and screen design or training are added when the project needs them. So the team is put together for each engagement, from our own people and, where needed, independent specialists whose role we present at kickoff.

Follow-up and acceptance.

  • Following the project

    How often we meet, and who attends, is set at kickoff. Each stage ends with a review of what was delivered, and decisions are recorded in writing, so everyone knows what was approved and by whom.

  • Acceptance

    Acceptance is based on the criteria set in stage 2. Your teams test on your system, with their own cases, and a part only counts as done once you've accepted it. Issues found are fixed and then checked again.

A system you can take over.

  • Separate environments

    Development happens away from your production.

  • Automated deployment

    Every release follows the same procedure.

  • You own the code

    It's handed over with its documentation at the end.

  • Revocable access

    Our access is listed and you can withdraw it.

  • Human sign-off for AI

    You decide with us what the system does on its own.

  • Confidentiality agreement

    It's signed before any consulting engagement.

What a scoping sheet contains.

This sheet sums up on one page what is agreed at the end of stage 2: the problem, what's in and out of scope, the owners on both sides, the acceptance criteria and the decision that closes the stage. It was written for this page and describes no client.

Illustrative example

Scoping sheet · Supplier invoice entry

Problem
Invoices arrive by email and are keyed into the ERP by hand, which slows processing and causes entry errors.
In scope
Reading invoices received by email, matching them to the purchase order, preparing the ERP entry for approval.
Out of scope
Expense claims, supplier payments, back-loading past invoices.
Owners
On the client side, the accounts payable manager and an IT contact. On Claro's side, a project owner and an integration engineer.
Acceptance criteria
On a sample of real invoices, every field read is correct or flagged for checking. No entry is posted without approval. Processing time is measured before and after.
End-of-stage decision
Go ahead with design on this scope and these criteria.

FAQ

Frequently asked questions

Can we start with a limited scope?

Yes, and that's often how we start. We pick one process or one team, with precise acceptance criteria, and the next step is decided on what that first scope showed. A small project still needs a real owner on your side, just like a large one.

What do you need from our teams?

We need a business owner who makes decisions, people who know the day-to-day work and, if your systems are involved, a technical contact. We also need access and real samples of documents or data. The time asked of each person is estimated at kickoff, since it depends on the project.

How long does a project take?

It depends on the agreed scope, the number of systems to connect and how available your teams are. So the timeline is set in stage 2, together with the scope and the investment, and each stage then has its own review date.

What happens after delivery?

You receive the code and the documentation, and we review the agreed measures. Follow-up then takes the form you choose: per ticket, a monthly arrangement with a written report, or your own team. Response times are set in your contract.

Let's discuss your priorities

Tell us about your situation.

Describe the problem, your constraints and the decision you need to make. We'll tell you which stage to start with and what you'll need to gather on your side.

  • The call lasts thirty minutes, by video.
  • You speak directly with a Claro expert.
  • Afterwards, we email you the next step we recommend.

Free initial consultation