A delivery pipeline for building Revally with AI

Revally helps restaurants, bars, pharmacies and other physical locations manage their online presence. The product brings together local search, syndication of business information to more than 50 platforms, review management, social content and AI-assisted capabilities.

Since early 2026, one of the three co-founders has served as CTO. The company has no dedicated engineering team.

A white-label partner solution made it possible to launch the service and learn from the market. The company is now building its own platform to own the experience, data and workflows that make the product different.

The partner product validated demand before the company committed to a full build. The new platform is therefore not a page-by-page reproduction. Revally is progressively rebuilding the capabilities where it needs to own the data model, user experience and pace of change.

Code can be proposed quickly, but the CTO still has limited review time. Each task must be precise enough for him to inspect the diff, test the behaviour and take over the implementation when needed.

This leaves review time for product behaviour, architecture and risk.

The platform runs on Next.js 16 and the App Router. Durable workflows run through Vercel’s Workflow SDK on Revally’s own infrastructure. The application is packaged with Docker, deployed through Coolify and hosted by OVH in France.

GitHub Actions runs linting, type checking, tests and the Next.js build, then builds the Docker image. Coolify deploys a preview for the pull request. The diff, check results and live environment give the CTO concrete material for review.

type RequiredCheck = 'lint' | 'typecheck' | 'tests' | 'build' | 'docker'
type CheckStatus = 'pending' | 'passed' | 'failed'
type ReviewFinding = { blocking: boolean }
type AutomatedReview = {
    status: CheckStatus
    findings: ReviewFinding[]
}
type Preview = {
    status: CheckStatus
    url?: string
    commitSha: string
}

type PullRequest = {
    headSha: string
    scope: {
        kind: 'single-task' | 'multi-task'
        check: CheckStatus
    }
    checks: Record<RequiredCheck, CheckStatus>
    preview: Preview
    automatedReview: AutomatedReview
    humanDecision: 'pending' | 'merge' | 'request-changes'
}

const requiredChecks: RequiredCheck[] = [
    'lint', 'typecheck', 'tests', 'build', 'docker',
]

const canMerge = (pullRequest: PullRequest) => {
    const allChecksPassed = requiredChecks.every(
        (name) => pullRequest.checks[name] === 'passed',
    )

    return (
        pullRequest.scope.kind === 'single-task' &&
        pullRequest.scope.check === 'passed' &&
        allChecksPassed &&
        pullRequest.preview.status === 'passed' &&
        Boolean(pullRequest.preview.url) &&
        pullRequest.preview.commitSha === pullRequest.headSha &&
        pullRequest.automatedReview.status === 'passed' &&
        !pullRequest.automatedReview.findings.some(
            ({ blocking }) => blocking,
        ) &&
        pullRequest.humanDecision === 'merge'
    )
}

This type illustrates the process; it does not reproduce the GitHub Actions file. The scope must be valid, every check must pass, the automated review must pass with no blocking findings and the preview must be ready for the current commit. The CTO then reads the diff, tests the relevant flow and chooses whether to merge or request changes.

AI assists with triage, preparation, development and review. A founder defines the expected outcome, and the CTO remains responsible for merging into the main branch.

1. 01

   Scope one task

   A founder defines the goal, acceptance criteria and what the pull request must not change.

2. 02

   Produce a first draft

   AI proposes an implementation, tests and revisions. Most of the initial code can come from this assisted work.

3. 03

   Run the automated checks

   GitHub Actions runs linting, type checking and tests, then builds the application and Docker image. Coolify deploys a pull-request preview.

4. 04

   Review and decide

   Automated reviews flag potential issues. The CTO inspects the diff, tests the user flow in the preview, then merges or requests changes.

Time already spent on a proposal is not a reason to keep it. If the result is unconvincing, the task goes back for revision or the implementation is discarded.

Most first-pass code is produced with AI assistance, but human review remains the limiting factor. Automation filters mechanical issues so that the CTO can focus on behaviour, architecture and product impact.