Skip to content
Aixo LabAixo Lab

How We Work

A structured software development process designed to reduce risk, improve transparency, and deliver maintainable digital products.

Process Overview

Eight stages, start to finish

Every project moves through the same sequence. Each stage has a defined output and a defined way you're involved — no open-ended phases.

  1. 01
    Discovery

    Understand the business problem and its real constraints.

    Output:
    Scope and goals document
    Your involvement:
    Initial workshop
  2. 02
    Product definition

    Translate the problem into concrete product requirements.

    Output:
    Feature spec and priorities
    Your involvement:
    Requirements review
  3. 03
    UX/UI design

    Design user flows and interface before development starts.

    Output:
    Wireframes and design system
    Your involvement:
    Design feedback
  4. 04
    Technical architecture

    Define system structure, data flow, and technology stack.

    Output:
    Architecture document
    Your involvement:
    Technical review (optional)
  5. 05
    Iterative development

    Build in short cycles with visible, regular progress.

    Output:
    Regularly shipped working versions
    Your involvement:
    Sprint review participation
  6. 06
    Quality assurance

    Test functionality, performance, and security before release.

    Output:
    Test results and fixes
    Your involvement:
    Acceptance sign-off
  7. 07
    Launch

    Deploy to production with a rollback plan in place.

    Output:
    Product deployed to production
    Your involvement:
    Launch approval
  8. 08
    Continuous improvement

    Monitor, maintain, and evolve the product after launch.

    Output:
    Maintenance and improvement roadmap
    Your involvement:
    Regular check-in meetings
Detailed Stages

What happens at each stage

A closer look at what we actually do, produce, and need from you at each point in the process.

  1. 01Discovery

    Understand the business problem, constraints, and success criteria before any solution is proposed.

    • Stakeholder workshop to surface goals, constraints, and existing systems
    • Review of any existing product, codebase, or documentation
    • Initial technical feasibility check
    Output:
    Scope and goals document
    Your involvement:
    One or more discovery workshops
  2. 02Product Strategy

    Translate the business problem into concrete, prioritized product requirements.

    • Feature definition and prioritization against the stated goals
    • User flow mapping for core journeys
    • Scope boundaries — what's in v1, what's deferred
    Output:
    Feature specification and priority list
    Your involvement:
    Requirements review and sign-off
  3. 03UX/UI Design

    Design user flows and interfaces before development starts, not in parallel with it.

    • Wireframes for core flows
    • Visual design against the product's design system (existing or newly established)
    • Usability review of key screens
    Output:
    Wireframes and a working design system
    Your involvement:
    Design review rounds
  4. 04Technical Architecture

    Define system structure, data flow, and technology choices before writing production code.

    • Architecture decisions — stack, data model, integrations
    • Identification of technical risk areas
    • Infrastructure and environment planning
    Output:
    Architecture document
    Your involvement:
    Technical review (optional, recommended for complex integrations)
  5. 05Agile Development

    Build in short, visible cycles rather than a single long build phase.

    • Development in sprints with a working, demonstrable increment each cycle
    • Regular sprint reviews
    • Ongoing backlog refinement as real usage clarifies priorities
    Output:
    Working software, shipped incrementally
    Your involvement:
    Sprint review participation
  6. 06Quality Assurance

    Verify functionality, performance, and security before release.

    • Automated test coverage for core logic
    • Manual QA against acceptance criteria
    • Regression testing before each release
    Output:
    Test results and a fixed-issue log
    Your involvement:
    Acceptance sign-off
  7. 07Deployment

    Ship to production with a rollback plan, not just a push.

    • Staging deployment and final verification
    • Production release, including store submission where applicable
    • Monitoring set up for the first release window
    Output:
    Live product in production
    Your involvement:
    Launch approval
  8. 08Continuous Improvement

    Monitor, maintain, and improve the product after launch — launch is a milestone, not an end point.

    • Monitoring and incident response
    • Bug fixes and maintenance releases
    • Roadmap planning for the next phase of work
    Output:
    Maintenance and improvement roadmap
    Your involvement:
    Regular check-in meetings
Communication

How we keep you informed

Transparency is a process, not a promise — here's what that actually looks like week to week.

Regular Meetings

Recurring check-ins at a cadence that matches the project, not a fixed template.

Progress Reporting

Clear status on what's done, what's in progress, and what's blocked — no vague updates.

Live Demos

Working software shown at each sprint review, not screenshots or slides.

Issue Tracking

A shared, visible backlog and issue tracker — you can see the same board we work from.

Decision Documentation

Significant technical and product decisions are written down, with the reasoning behind them.

Transparent Scope Management

Scope changes are flagged and discussed as soon as they come up, not absorbed silently or discovered at delivery.
Quality Assurance

How we verify before we ship

Quality is built into the process, not inspected in at the end.

Acceptance Criteria

Every feature has defined, testable criteria agreed before development starts.

Code Review

Every change is reviewed by another engineer before merging.

Automated Tests

Core logic and critical paths are covered by automated tests, not just manual checking.

Manual QA

Human testing against real usage scenarios, not just automated coverage.

Regression Testing

Existing functionality is verified before every release, not just new features.

Release Checks

A defined checklist before anything reaches production — no ad hoc deployments.
Delivery and Deployment

From staging to production, and after

Every release goes through a staging environment for final verification before it reaches production. For mobile apps, that includes app store and Google Play submission, review, and release management.

After launch, we set up monitoring so issues are caught early rather than reported by users. Ongoing maintenance — bug fixes, dependency updates, and performance monitoring — continues for as long as you need it, not just through a fixed warranty window.

Engagement Models

How we structure the work

The right model depends on what stage your project is at and how much ongoing involvement you need.

Scoped Project

A defined project with clear requirements, timeline, and deliverables — the right fit when scope is well understood.

MVP

A focused first version built to validate the core idea quickly, with a clear path to expand afterward.

Dedicated Product Team

An ongoing team embedded with your product for continuous development, not a single fixed-scope engagement.

Ongoing Maintenance and Evolution

Continued support, improvement, and feature development for a product already in production.

Ready to start with discovery?

Tell us what you're planning, and we'll walk you through how this process would apply to your project.

No obligation — a discovery call is a conversation, not a sales pitch.