One Operator, Ten Products: Cross-Project Orchestration in Practice

Running one SaaS product with AI assistance is a solved demo. Running ten — different stacks, different repos, different customers, different deploy targets — is where the interesting problems live. Not because any single project is hard, but because **context doesn't scale the way code does**.

This is the portfolio problem: a Rails app, two Next.js apps, an Elixir service, and a Go platform all need CI triage, roadmap upkeep, feedback conversion, content, and releases. One human can't hold ten project contexts. The naive fix — one agent per project, each with its own tools and state — just moves the fragmentation somewhere more expensive. The fix that works is a single operations layer where projects are *scopes*, not silos.

Projects as scopes, not silos

The core move: every entity in the system — memory, task, feedback item, roadmap entry, release, contact — carries a `project_id`. Tools accept it. Queries filter by it. An agent session opens *in the scope of* a project and inherits its conventions, memories, and pending work.

That one decision unlocks the portfolio pattern:

- **Per-project depth when scoped.** Ask about FeelTrack and you get FeelTrack's conventions, FeelTrack's open tasks, FeelTrack's deploy history.

- **Portfolio breadth when unscoped.** Ask "what's on fire?" and the same tools answer across all ten: which domains are down, which CI is red, which feedback is aging, which tasks are stale.

One operator, one memory store, one audit chain — ten lenses.

The three portfolio-level views that matter

Cross-project orchestration lives or dies on a small set of aggregate views. These are the ones that earn their tokens daily:

**1. The standup.** Task counts, blockers, and high-priority items across every project, in one call. This is the operator's morning: not ten dashboards, one answer — "three blocked tasks, two of them waiting on the same secret rotation; here's the escalation."

**2. The health sweep.** Uptime across all tenant domains, CI status across all repos, heartbeat freshness. The key is that failures *convert into scoped tasks automatically*: the sweep notices `lilo` returning 502, and the task it opens is scoped to lilo, with lilo's conventions attached. Detection is portfolio-wide; remediation is project-deep.

**3. The triage queue.** Untriaged feedback across every project, grouped and pre-scored. Customer signals rot fast; a portfolio view that says "four bug reports across three projects, two likely the same root cause" turns a week's inbox into a fifteen-minute decision session.

What transfers between projects (and what must not)

The subtle art of multi-project memory is deciding what crosses scope boundaries:

**Transfers:** conventions and patterns. The fix for "Prisma loads `.env`, not `.env.local`" in one Next.js app is instantly valuable to the other three. Convention profiles let you promote a hard-won lesson to a shared layer — write once, inject everywhere relevant. Deploy patterns, lint configs, incident runbooks: same story.

**Must not transfer:** tenant data. Memories, contacts, feedback, and secrets stay hard-scoped. A memory written inside project A never surfaces in project B's context unless it was explicitly promoted to a shared profile. Cross-project *learning* is a feature; cross-project *leakage* is an incident. The distinction has to be mechanical — enforced by scoping in the query layer, not by asking the model nicely.

The operator's day, reorganized

Before: open ten repos, read ten CIs, skim ten inboxes, context-switch forty times, drop three balls.

After: one session. The standup view flags the two projects needing judgment. The agent drafts the week in each scope, escalates the one red-zone decision with evidence attached, and files structured summaries of everything else. The human's job compresses to the exceptions — which is the entire thesis of supervised autonomy, applied at portfolio scale.

The compounding effect

The underrated win isn't time; it's **institutional memory that outlives attention**. When project seven hits the same Postgres connection-leak project two survived in March, the recall surfaces the March postmortem — versioned, dated, with the fix. A solo operator with ten products stops being a person juggling and becomes a small platform team with one employee.

Ten products, one operator, zero dropped contexts. That's the portfolio pattern.

---

*Part of the FlukeBase supervised-autonomy series. Next: inside the agent worker — dispatch, execute, report.*