Process Overview

EmeSoft runs an AI-augmented, Scrum-based delivery process. The Agile mechanics are deliberately conventional - two-week sprints, a single prioritized backlog, the standard ceremonies - because predictability is the point. What makes 2026 different is that every role has AI assistance woven into its daily work, with a human always accountable for the outcome.

The three layers

The process is easiest to understand as three layers stacked on top of each other.

flowchart TB
    subgraph L1[Layer 1 - Direction]
        direction LR
        ST[Stakeholders / Product Owner] --- PM[Project Manager]
    end
    subgraph L2[Layer 2 - Definition & Design]
        direction LR
        BA[Business Analyst] --- SA[Solutions Architect / Dev Lead]
    end
    subgraph L3[Layer 3 - Build, Verify & Run]
        direction LR
        DEV[Developers] --- Q[Quality Controller - Manual/Automation] --- CE[Cloud Engineer - DevOps]
    end
    L1 --> L2 --> L3

The Direction layer decides why and what. The Definition & Design layer turns intent into buildable, testable specifications and a sound architecture. The Build & Verify layer produces and validates the working software, then feeds results back up so direction can adjust.

End-to-end value flow

A single piece of work - an epic broken into stories - travels through the organization like this:

sequenceDiagram
    participant ST as Stakeholder / PO
    participant BA as Business Analyst
    participant SA as Solutions Architect
    participant DEV as Developer
    participant Q as Quality Engineer
    participant CE as Cloud Engineer

    ST->>ST: Business need + epic & value hypothesis (AI-assisted)
    ST->>BA: Epic for refinement
    BA->>BA: User stories + acceptance criteria (AI-assisted)
    BA->>SA: Refined backlog item
    SA->>SA: Technical design + task breakdown (AI-assisted)
    SA->>DEV: Estimated, designed tasks
    DEV->>DEV: Implement + unit tests (AI pair-programming)
    DEV->>Q: Pull request
    Q->>Q: Code review + standards + security scan (AI-assisted)
    Q->>Q: Functional / regression / E2E (AI-generated tests)
    Q->>CE: Validated increment
    CE->>CE: Provision + deploy via IaC/CI-CD + monitor (AI-assisted)
    CE->>ST: Released, observable increment
    ST->>ST: Sprint demo + outcome data
    ST->>BA: Feedback → next priorities

Data projects add a Data Engineer

The flow above describes every project. Data-centric projects add a Data Engineer who designs and builds the data pipelines feeding the increment - ingesting, transforming, and serving data for decisions - working alongside the Architect and Cloud Engineer. On non-data projects this role is simply absent.

What “AI-augmented” means here

It does not mean AI replaces roles or makes decisions autonomously. It means each role uses AI to remove toil and raise quality, while keeping a human in the loop:

• Drafting, not deciding - AI produces first drafts of stories, designs, code, and tests; humans review, correct, and own them.
• Acceleration, not autonomy - AI compresses the time from intent to artifact; it does not approve merges, sign off releases, or commit to scope.
• Augmented review - AI acts as a tireless first-pass reviewer (security, style, edge cases) so humans focus on judgment calls.

The exact tools per role are in the AI Tooling Map, and the guardrails are in Integration & Governance.

Cadence at a glance

Cadence	Event	Primary owner	Output
Daily	Daily Scrum	Project Manager (Scrum Master)	Synced plan, surfaced blockers
Per item	Backlog refinement	Stakeholders (PO) + BA	Ready, estimated stories
Every 2 weeks	Sprint Planning	BA + Team (stakeholder priorities)	Sprint Goal + Sprint Backlog
Every 2 weeks	Sprint Review	Stakeholders (PO) + Team	Demo, stakeholder feedback
Every 2 weeks	Retrospective	Whole team	Improvement actions
Continuous	CI/CD + AI checks	Architect/Dev Lead + Quality Engineer	Shippable increment
Continuous	Deploy, monitor & IaC	Cloud Engineer (DevOps)	Running, observable system

Guiding principles

1. A human owns every output. AI assists; people are accountable.
2. One prioritized backlog. No shadow work, no side channels.
3. Quality is built in, not inspected in. Code review and testing start at refinement, not after code.
4. Document the reality. We capture what broke and what we changed - see Field Notes.
5. Small, frequent, reversible changes. Smaller increments are safer to ship and easier for AI to reason about.