// site/sections-b.jsx — use-cases · engine (value stream) · true picture · outcomes · cost · story // ════════════════════════════════════════════════════════════════════════ // WHAT CAN YOU BRING? — 6 concrete use-case cards // ════════════════════════════════════════════════════════════════════════ function UseCases() { const cards = [ { icon: "bolt", t: "Stuck feature", d: "A feature that has been planned for weeks but keeps losing priority to urgent work. Wakalix puts the right roles on it and produces a reviewable PR." }, { icon: "refresh", t: "Migration", d: "A framework, API, dependency, or infrastructure migration nobody has time to finish. The engine works inside your systems, against your standards." }, { icon: "check", t: "Flaky test suite", d: "A test suite that slows releases and wastes review cycles. Roles identify failure patterns, fix unstable tests, and hand your team a clean, documented result." }, { icon: "layers", t: "Legacy refactor", d: "A module that works but is too risky or unclear to change. The engine maps it, refactors it incrementally, and keeps it reviewable at every step." }, { icon: "book", t: "Docs & SDK cleanup", d: "API docs, examples, onboarding guides, SDK improvements. Work your team never quite has time to get to — done properly, with your engineers approving what ships." }, { icon: "shield", t: "Production readiness", d: "Observability gaps, error handling, resilience, security hardening, release checks. The unglamorous work that protects what you've already built." }, ]; return (
What can you bring?

One real problem. Any kind.

No migration, no long transformation program. Bring one thing that has been waiting on time, focus, or senior capacity. Wakalix forms the right AI roles around it and produces reviewable work your team can approve.

{cards.map((c, i) => (
{c.t}
{c.d}
 ))}
); } // ════════════════════════════════════════════════════════════════════════ // THE ENGINE — SEE, the Software Engineering Engine (20 roles, end to end) // ════════════════════════════════════════════════════════════════════════ function ValueStream() { const stages = [ { n: "01", stage: "Strategy & governance", icon: "target", tier: "portfolio", count: 3, d: "A chief architect, a governance auditor and a delivery lead set direction, guard your standards, and keep the work honest." }, { n: "02", stage: "Product & design", icon: "sparkle", tier: "product", count: 3, d: "Product managers and architects turn an idea into a real plan; an experience designer shapes how it feels to use." }, { n: "03", stage: "Platform & security", icon: "shield", tier: "product", count: 2, d: "A platform engineer lays the foundations and a security auditor keeps them safe — before a line of feature code is written." }, { n: "04", stage: "Build", icon: "box", tier: "developer", count: 4, d: "Backend, frontend, data and integration engineers do the actual building — in your systems, to your conventions." }, { n: "05", stage: "Quality", icon: "check", tier: "helper", count: 4, d: "Code review, testing, accessibility and documentation — the checks teams usually skip under pressure, done every time." }, { n: "06", stage: "Implementation", icon: "dispatch", tier: "helper", count: 2, d: "Release managers and deployment specialists get the work live cleanly, reliably, and with every step documented and reversible." }, { n: "07", stage: "Support & operations", icon: "refresh", tier: "helper", count: 3, d: "Site reliability, support and observability roles keep the product healthy, responsive to real users, and improving after launch." }, ]; return (
The engine, in full

The complete software value stream.

Every stage the work needs — from first idea all the way through to live in production and supported by real users — covered by one connected engine, not a pile of disconnected bots. The engine works inside your engineering organization, against your standards, and produces reviewable work at every step. We have a proven way to onboard these roles into your organization: your codebase, your conventions, your guardrails.

{/* one clean diagram: idea → production track + six stage write-ups */}
IDEA IN PRODUCTION
{stages.map((s) => (
{s.n}
{s.stage} {s.count} roles
{s.d}
))}
{/* concrete example callout */}
Example — flaky test suite
For a flaky test suite, the engine brings in a test engineer, backend engineer, code reviewer, delivery lead, and documentation role.
{["Identifies failure patterns across the suite","Fixes unstable tests against your conventions","Updates the relevant documentation","Opens a reviewable PR with evidence — your team approves it"].map((l, i) => ( {l} ))}
{[ { icon: "grid", t: "20+ roles, the complete value stream" }, { icon: "route", t: "Proven onboarding into your org" }, { icon: "refresh", t: "Gets sharper every run" }, ].map((c, i) => ( {c.t} ))}
); } // ════════════════════════════════════════════════════════════════════════ // THE TRUE PICTURE — replaces the technical "git as memory" framing // ════════════════════════════════════════════════════════════════════════ function PicturePanel() { const quality = [62, 70, 68, 79, 85, 90]; return (
Roadmap, as it really is live
{/* three honest signals */}
On track
roadmap status, ground-truth
+38%
quality trend, this quarter
{/* quality trend bars */}
Quality, climbing
{quality.map((h, i) => (
))}
{/* innovation mix */}
Effort on new value vs. upkeep 66%
); } function Picture() { const points = [ "A true picture of your roadmap — what's really moving, what's stuck, and why — not a slide written the night before the review.", "Quality you can watch trend over time, instead of finding out at release.", "How much of your effort is going to real innovation versus keeping the lights on.", ]; return (
See the true picture

Finally see what your roadmap is really made of.

Because the engine does the work as one connected system, nothing happens off the record. That gives you something most teams never get: an honest, always-current view of your own delivery.

    {points.map((p, j) =>
  • {p}
    • )}
); } // ════════════════════════════════════════════════════════════════════════ // OUTCOMES — quick "what changes" summary // ════════════════════════════════════════════════════════════════════════ function Outcomes() { const cols = [ { k: "Ship faster", icon: "bolt", d: "Clear the backlog that's been waiting on headcount. Work that sat for quarters starts moving in weeks." }, { k: "Spend far less", icon: "coin", d: "A fraction of the cost of new hires — and a fraction of what an unmanaged coding agent burns in tokens." }, { k: "Build what you couldn't", icon: "sparkle", d: "Finally take on the projects there was never time or people for — without pulling your team off the roadmap." }, ]; return (
What changes

More shipped, for less.

{cols.map((c, i) => (
{c.k}
{c.d}
 ))}
); } // ════════════════════════════════════════════════════════════════════════ // COST — the headline differentiator (token-budget pain + proof) // ════════════════════════════════════════════════════════════════════════ function CostPanel() { const models = [ { label: "Light model", pct: 64, note: "mechanical work", c: "var(--ok)" }, { label: "Standard model", pct: 31, note: "most delivery", c: "var(--accent)" }, { label: "Premium model", pct: 5, note: "hard design only", c: "var(--tier-portfolio)" }, ]; return (
This month under cap
$184 / $2,400 budget
alerts fire at 80% — you never get a surprise bill
Right-sized models
{models.map((m) => (
{m.label} · {m.note} {m.pct}%
))}
); } function Cost() { const points = [ "Every job gets the cheapest model that can do it well — premium models fire only on genuinely hard design.", "A hard spend cap per role, per project. Alerts before you reach it; nothing runs away in the background.", "Every dollar accounted for — re-run the cost picture any time. The bill is never a mystery.", ]; return (
Predictable AI spend

Coding agents burn through budgets.
This one doesn't.

If your team's coding-agent bill swings wildly month to month — premium models firing on trivial work, no caps, no visibility — you already know the problem. wakalix is built cost-first.

    {points.map((p, j) =>
  • {p}
    • )}
~$150/mo
is what it cost us to run our entire portfolio of products — AI and infrastructure, all in.
Your cost depends on project size, complexity, and run frequency. We show you the cost model before any work starts — no surprises.
); } // ════════════════════════════════════════════════════════════════════════ // OUR STORY — track record as a case study (proof) // ════════════════════════════════════════════════════════════════════════ function Story() { const stats = [ { n: "Multiple", l: "products built" }, { n: "Weeks", l: "not quarters" }, { n: "Elite", l: "delivery metrics" }, { n: "0", l: "quality regressions" }, ]; return (
Proof, not promises

We built our own company this way.

Before we offered this to anyone, we ran the engine on ourselves. A small group of people and the full roster of AI roles built and shipped a portfolio of real products — live, in production.

Your story will look different from ours. But the way the work gets done — the engine doing the legwork, your people deciding — is exactly what we'll bring to your team.

Our own track record
{stats.map((s, i) => (
{s.n}
{s.l}
))}
We'll walk you through the real numbers behind every one of these in a call — measured, not estimated.
); } Object.assign(window, { UseCases, ValueStream, Picture, Outcomes, Cost, Story });