A founder story · March 2026

Built From
the Rubble How Steller survived a war, a broken codebase,
and the AI that finally fixed everything

A B2B gift card platform. A development team in a conflict zone. A $10,000 project that couldn't be finished. And one non-coder founder who had to rebuild it all — with nothing but AI agents and a deadline.

↓ Scroll to read the full story
01
The beginning

A gap in the market.
A team across the world.

The idea for Steller was simple. Businesses that wanted to offer digital gift cards — loyalty programs, employee rewards, consumer promotions — had no clean way to connect to the vendors who supplied them. There was a gap in the market for a reliable B2B middleware: a layer that sat between integration partners and gift card vendors, handled the wallets, processed the orders, and returned the PINs.

I saw the gap. I knew how to close deals, structure pricing, and bring partners on board. What I could not do was write software. So I did what most non-technical founders do: I outsourced. A development team from the Middle East, working on a project basis. The total engagement: $10,000.

The team was talented. They designed a technically ambitious architecture — a modern microservices stack built on ASP.NET Core 9, PostgreSQL, RabbitMQ for asynchronous processing, Vue.js dashboards. By April 2025, the foundational database was live: 36 tables, the full data model for an order management system. By July, security features were implemented. By November, soft delete for compliance. By December, the frontend dashboards were taking shape.

On paper, it looked like a real product was being built.

Pre-April 2025
Architecture defined
Microservices stack locked: ASP.NET Core 9, PostgreSQL, RabbitMQ, Vue.js. Bamboo Card Portal API as the vendor integration target.
April 2, 2025
Core data model live
Initial migration deployed. 36 tables: users, orders, inventory, wallets, brands, catalog. The foundation of a real system.
May–November 2025
Feature build: currency, security, compliance
Multi-currency rate tables. Password reset flows. Soft-delete audit trail. The system was growing. The team was building.
Late 2025
Frontend dashboards begun
Vue.js admin and consumer dashboards enter development, suggesting backend was approaching feature-completeness.
December 6, 2025
Final sync migration
A maintenance migration to synchronize all environments. Typically a signal that deployment is approaching.
02
The collapse

The team went offline.
The architecture stayed.

In late 2025 the development team went offline. They were a team in a conflict zone, displaced by war. What they left was a codebase full of invisible debt, and a partner integration deadline that did not move with them.

The instinct most founders would follow is replacement. Find another developer. Pick up where the last team left off. Finish what was started. That is not what happened. The $10,000 engagement had produced a real data model and a real stack. It had not produced a system a non-coder could keep alive.

What I had instead was the architecture they left, a production server still tied to that conflict zone, and AI agents — Cursor, Qwen, Claude — as the only engineering capacity left. I am not a developer. I build Steller with those agents. No engineering team. No CTO. Just me and a context window.

"Every time I asked the agent to fix an order flow bug, it changed the right service — but broke two others it couldn't see."
Muhanad Abdelrahim — Founder, Steller
03
The blind spot

Microservices looked correct.
Agents could not hold them.

Steller started as a textbook microservices architecture. RabbitMQ for messaging. Separate services for orders, wallets, catalog, webhooks. The kind of system that looks impressive in a diagram and makes senior engineers nod.

For a large human team, that shape is a feature. For a team of one human and several AI agents, it was a disaster. Every session started the same way. I would describe a bug — orders completing while wallets were not debited, or debited twice. The agent loaded the order service, made a change, and reported success. The wallet service was still wrong, because the agent had never seen it.

The order service published an event. The wallet service subscribed. Those were two codebases and two context windows. When I asked the agent to fix the order flow, it could only see the part of the flow in the file it was reading. The consumer, the wallet debit, the Bamboo vendor call, the webhook dispatch — invisible.

"Separate services will keep the system clean."
What the agent actually hit
Context fragmented across files and services
An order flow needs wallet logic, vendor integration, job scheduling, and webhook delivery in view at once. Each file the agent loaded displaced something else. It never held the whole path.
"The queue is the contract. That is enough."
What the agent actually hit
RabbitMQ hid the dependency
Message queues are asynchronous and implicit. An agent fixing a publisher has no signal that a consumer exists, or what contract it expects. Every RabbitMQ change was a gamble.
"The agent will orient itself each session."
What the agent actually hit
Fifteen to twenty minutes before any work
Sessions opened with "let me find which service handles this." Infrastructure — exchanges, bindings, dead-letters — filled the window before business logic did.
"A saga will roll the wallet back if Bamboo fails."
What the agent actually hit
Compensating transactions no agent could trace
Rollback lived as choreography across services. No single file held the forward path and the undo. The agent guessed, or it stopped.
"The unit of architecture for agentic development is not the service boundary — it's the context window."

Microservices optimise for team independence. Agentic architecture has to optimise for context visibility. Those are different goals, and they often require opposite design decisions. The message queue — the thing that makes microservices powerful for human teams — is exactly what makes them hostile to agents.

04
The redesign

Fat controllers.
The whole golden flow in one file.

I am not saying microservices are wrong. I am saying they are wrong for a small team using AI agents as the primary development force. For a team of thirty engineers they can still be the right answer. For one human and several agents, they were architectural poison.

The replacement is plain. Fat controllers: the order flow — wallet debit, Bamboo vendor call, PIN return, webhook dispatch — lives in one controller, readable top to bottom. Hangfire for background work: jobs are named C# classes. PlaceBambooOrderJob is a file an agent can grep, open, and read, including the wallet rollback when Bamboo fails.

The pivot was deliberate, not a rescue of the old shape. Service boundaries were consolidated. The two Vue.js 2.6 dashboards were decommissioned and replaced with a unified React 18 / TypeScript / Vite frontend. Fragmented API responses became a single mandatory envelope. Permission lookup tables were flattened. The patterns that helped a human team navigate were replaced with patterns an agent can operate.

Before — what the agent could see
Distributed. Decoupled. Agent-hostile.
Partner API
↓
OrderService
↓
bus.Publish("OrderPlaced")
↓
??? another service
↓
??? another context window
↓
Agent loses the thread
A bug in order → debit → fulfill → webhook required four services in context at once. The agent never held them.
After — what the agent can see
Concentrated. Explicit. Agent-ready.
Partner API
↓
OrdersController
↓
wallets.DebitAsync()
↓
Enqueue PlaceBambooOrderJob
↓
Return OK + orderId
One repo. One Docker Compose. AGENTS.md says which file to open first. Compensating transactions are explicit code in the same path, not saga choreography.

This is not clean-code theory. It is what an agent can reason about when something is broken: read the controller from top to bottom, grep the named job, find the rollback. Session orientation dropped from the fifteen-to-twenty-minute search to about two minutes — read AGENTS.md, open the controller, start the work.

05
Twenty-seven days

From the reckoning
to a system Qwen could run.

The pivot took 27 days and cost $672 in Cursor usage. That is the published cost of transforming the microservices system into an agent-ready monolith — architectural planning, the code transformation, the documentation, and the protocol layer that lets Qwen operate the system day to day. The rebuild shipped with zero critical defects in production.

Feb 16–22 · $207 · Peak intensity
The architectural reckoning
The most expensive week — $44 on Feb 21 alone. Cursor plus high-thinking model calls, planning the move from RabbitMQ to Hangfire. Six calls at two to eight million tokens each. This is what it cost to think at architectural scale.
Pivot
Feb 23 – Mar 1 · $163 · Execution
RabbitMQ out, Hangfire in
Controllers grew fat. Services got absorbed. The golden flow — place order, debit wallet, call Bamboo, return PINs, fire webhook — collapsed into a single readable path. For the first time the agent could see the whole picture.
Pivot
Mar 2–8 · $118 · Hardening
The agent protocol layer
AGENTS.md, QWEN_PROTOCOL.md, HANDOVER_TO_QWEN.md, CHANGELOG_AI.md. Guardrails, confirmation gates, session protocols, canonical port maps. The system became legible to machines.
Mar 9–14 · $96 · Stabilisation
Handed to Qwen Coder
Spend dropped by half week over week. The system no longer needed the heavy architectural sessions — Qwen could operate it from the docs. Bede, the Zain digital wallet, entered staging. Steller was ready for its first partner integration.
Live path
Published cost of the pivot
Cursor spend, all-in
$672
Total $672
The same case study puts a five-person team for that scope at $80,000–150,000. The four phase totals above are the published weekly figures; they are not a second invoice.
$672
Cursor spend to complete the pivot
27d
Microservices to agent-ready monolith
~$15
Expected daily AI spend after handover
0
Full-time developers required

Expected daily Cursor and Qwen spend after the pivot, for routine operations, was about $15. A 95.2% cache hit rate is why the documentation compounds: files written once are read across hundreds of sessions. Bede — the digital wallet of Zain Sudan — moved from staging into an active API integration. The platform onboards partners to a first successful API transaction in under sixty seconds.

"The lesson isn't that microservices are wrong. It's that microservices are wrong for a team of one human and several AI agents."
Muhanad Abdelrahim — Founder, Steller · March 2026
06
The scorecard

Microservices versus fat controllers
for an agentic team.

Dimension
Microservices + RabbitMQ
Fat controllers + Hangfire
Context window
Fragmented. The agent loads a fraction of the system per session.
Single repo. The golden flow is readable in one file.
Orientation
15–20 minutes. "Which service handles this?"
About 2 minutes. Read AGENTS.md, open the controller.
Debugging a flow
Trace a message through three or more services. Often a guess.
Read the controller top to bottom. The cause is visible.
Background jobs
Implicit event names. Nothing to grep.
Named classes. PlaceBambooOrderJob is findable in one search.
Rollback
Saga choreography across services.
Explicit rollback in the same file as the forward path.
Infrastructure
Exchanges, bindings, and dead-letters before any business logic.
Hangfire is a package and a Postgres table.
Deploy
N services, N deployments.
docker compose up -d. One command, one log stream.
Docs
Each service has its own docs. The agent cannot tell which are current.
One AGENTS.md, one port map, one backlog.
Cost to operate with AI
High. Constant re-orientation. Errors from missing context.
Qwen operates on about $5–15 a day once the docs exist.
07
The limits

This is not a universal rule.
It is a constraint.

Fat controllers break when a team grows past a handful of engineers. At that scale, several people editing the same controller create the merge conflicts microservices were designed to avoid. The context-window argument fades when humans can hold the context themselves.

Independent scaling becomes impossible. If the Bamboo integration needs many times the resources of catalog sync, one controller cannot scale those paths apart. Very large domains get unwieldy too. A controller that handles dozens of flows is not readable to a human or an agent. Steller has one golden flow, not forty.

The principle is not "always use fat controllers." The principle is: design the architecture so an AI agent can hold the entire relevant flow in a single context window. For Steller at this stage, that meant fat controllers. For a larger system, it might mean domain-bounded services with explicit, synchronous interfaces — not event-driven, and not invisible.

08
The principles

Rules for building with
agents, not a department.

01
Keep the golden flow in one file
An agent should read the path from request to response without crossing a service boundary. If it has to cross one, merge the services.
One flow · one sitting
02
Name everything so it can be grepped
Hangfire jobs, middleware, services — unique strings. PlaceBambooOrderJob, ReconciliationJob, SendWebhookJob. Implicit pub/sub is context poison.
If you cannot search it, the agent cannot see it
03
Write AGENTS.md before the code
It tells the agent where to start, what to protect, and which commands to run. A good one cuts orientation from about twenty minutes to about two.
The most valuable file in the repo
04
Make the wrong move unambiguously wrong
Protected flags, confirmation gates, remediation locks. An agent that cannot accidentally break a protected system is worth ten that might.
Safety is architecture
05
One deploy command
docker compose up -d. If an agent needs five commands to start the system, the system is too complex for agentic operation.
One command · one log stream
06
Treat docs as the real codebase
At a 95.2% cache hit rate, the docs are read hundreds of times. An hour on a runbook saves days of re-orientation.
Docs compound
07
Require test output before "done"
An agent that shows dotnet test output is verifiably further along than one that says "looks good." Make the output a session exit condition.
Show the run, not the reassurance
08
Log what the agent changed
CHANGELOG_AI.md is the memory one agent passes to the next. Without it, every session starts from zero.
Session memory, not bureaucracy

Steller is now operated by Qwen Coder. It reads AGENTS.md at the start of a session, runs tests before calling the work done, and logs what it changed. One non-coder founder. Several AI agents. Zero full-time developers. And a system designed for the intelligence that actually runs it.

The human-interest version of this story — AI finished what the developers could not — leaves out the judgment. The complete account is the next essay.

Next in the series
Issue 03 · The complete account
The Complete Story
Why the rebuild was a redesign, not a rescue.
Read the essay →