How we shipped enterprise wallet infrastructure in 7 days (with 3 people and AI agents)

Late 2025, a client came to us needing enterprise wallet infrastructure — custody, multi-sig approvals, treasury reporting, the works — for a product launch that was already announced. The original vendor had dropped out. The launch was in eight days. They asked if it was possible.

We shipped in seven. Team of three. This is exactly how, including the parts that were embarrassing and the parts I'd only do again if the client understood the trade.

The 7-day constraint

The scope, as originally quoted by the departed vendor, was ten weeks. Team of six. What we agreed to deliver in seven days:

• Custody wallets (hot + warm, no cold storage in v1)
• Multi-signature approval flow with role-based policy
• Treasury dashboard: balance, transaction history, export
• Webhook integration with the client's existing back-office
• Basic reconciliation reports

What we cut and deferred to v2:

• Cold storage integration (delivered week 3, off the critical path)
• Custom RBAC beyond three roles (client accepted three roles for launch)
• The reporting suite with configurable dashboards (they got CSV export instead)
• Every branded UI polish item that wasn't blocking usability

Team composition

Three people, each with a very defined lane:

• One senior full-stack (me) — architecture, integration boundaries, unblocking
• One backend specialist — smart contracts, custody logic, the parts where getting it wrong costs real money
• One frontend + product engineer — dashboard, approval UX, the client-facing polish

No PM. No designer. No QA function. The client had a technical founder who acted as product owner in a shared Slack. The reason a team of three worked is not that we're superhuman — it's that we had zero coordination overhead. Every decision had one owner. Every disagreement was resolved in the shared channel within an hour or escalated to me.

The AI-agent workflow (this is the part that changed everything)

This project is the reason I now believe the "single senior engineer + AI agents" pattern is a structurally different mode of software delivery, not a marginal productivity boost. Concretely:

• Claude Code ran as a background agent on scaffolding, boilerplate, tests, and refactors. Every morning I'd queue up 10–15 well-scoped tasks; by lunchtime most were done and reviewed.
• Cursor was the primary editor for anything requiring active human judgement — smart contract logic, custody flows, policy engine. Chat + inline suggestions, no full agent mode.
• GitHub Copilot handled the last-mile completions in files we'd already touched.
• For architecture decisions, we used Claude in a Projects context loaded with our design docs, and treated it as a fourth voice in every design review.

The workflow that worked was aggressive scoping into small, verifiable units. "Add a policy engine" is a bad task. "Add a policy engine that evaluates the following four rules against a transaction and returns approve/reject/escalate, with these five unit tests" is a great task. Well-scoped tasks with clear acceptance criteria are what turns AI-augmented development from marketing copy into actual throughput.

Architecture bets that paid off

Three bets we made on day one that we'd have questioned if we had more time:

1. Boring stack. Postgres, TypeScript, Next.js, one Solidity contract, viem for chain interaction. Nothing where we'd hit a bug that couldn't be Googled or Claude'd in five minutes.
2. Event-sourced ledger, no live balance table. Every transaction wrote an event; balances were derived. Simpler code, and it made reconciliation trivial — the reconciliation report was literally a SQL query over the events.
3. Multi-sig as policy-first, not signature-first. We didn't build a generic multi-sig contract; we built a policy engine off-chain that decided when a transaction needed multiple signatures, then requested them. Much easier to change policy than to redeploy contracts.

Rituals

The rituals were minimal but non-negotiable:

• 10-minute daily kickoff at 9am. One sentence: what am I shipping today, what's blocking me.
• Live demo to the client at 6pm every day. This is the single most important ritual. If it doesn't demo, it's not shipped.
• End-of-day merge to main. No long-lived branches. Everything went behind a feature flag if it wasn't ready to be seen.
• Weekend was a real weekend. We shipped Sunday night for the Monday launch; nobody worked Saturday. Burnout was not a productivity gain we could afford.

What went wrong

Two things went wrong that are worth being honest about.

First, we shipped a subtle bug in the approval policy on day 5 that would have let a single admin approve their own transaction under a specific edge case. Caught in the day-6 client demo. Fixed in an hour. It shipped because I had reviewed the PR at 11pm and skimmed. Lesson: no PR reviews after 10pm, ever.

Second, we underestimated the ops work. The code was ready by end of day 6. Getting it into the client's production environment — VPN access, secrets management, their existing observability stack — took most of day 7. If I did this again I would allocate a full day to "landing" from the start.

When you should do this

Not always. Compressing a year of work into a week has real costs:

• The client has to accept a stripped scope and trust you on cuts. If they don't, you'll re-litigate every deferred item and lose the week.
• The team has to be genuinely senior. This is not a mode where you can bring junior engineers along; there's no time to teach.
• You need to be willing to ship boring. Anything ambitious is an on-fire risk when the timeline is measured in days.

But when it fits, it's the highest-leverage mode of engineering I've ever worked in. The client got their product launched on time. We got a case study, a long-term retainer, and a template we've now used on four other engagements. And every time, the AI-agent workflow makes it a little more possible for a team of three to do what used to require a team of ten.