Build it fast. Build it right. Deliver on promise.
Your job: execute the design, hit the timeline, and deliver zero-production-incident quality. Sales landed the deal. SA designed it. You build it, test it, deploy it, and hand it off. Here's what excellence looks like.
What you own.
You own the execution. On-time, on-budget, on-quality — zero exceptions. Your success metrics: deliver within the budget timeline, zero production incidents, client trains on day 1.
The imperative: Build to the SA's design, not your design. No scope creep. No "just one more feature." No shipping incomplete work hoping the client won't notice. You're building a production system that runs forever.
Map the AI estate. 3 weeks. On schedule.
SA designed how discovery runs. You execute it. Collect data from cloud APIs, telemetry, logs. Normalize it. Deliver a clean inventory to the assessment team.
Your sprint (weeks 1–3)
- Week 1: Data access (cloud creds, API keys, log setup). First data pull. Validate quality.
- Week 2: Normalize data into the inventory schema. Dedup. QA.
- Week 3: Final inventory + shadow-AI report. Ready for assessment.
- Daily: Sync with SA on data quality. Flag blockers fast.
Success criteria (you deliver)
- ✓ 95%+ coverage (assets/models found).
- ✓ Clean, deduplicated inventory (no duplicates, no junk).
- ✓ Shadow-AI findings (unapproved tools + users).
- ✓ Zero data loss or errors in normalization.
- ✓ Documented data flow (for ops handoff).
Delivery wins: If you deliver 95%+ coverage on day 21, assessment starts on day 22 (no delay). If you miss, you cost the engagement a week.
Score the controls. 4 weeks. Rigorous QA.
SA designed the control library + scoring logic. You execute. Score each asset/model against each control. Gather evidence. Prepare the readout.
Your sprint (weeks 4–7)
- Week 4: Assessment setup. Load control library. Confirm scoring logic with SA.
- Weeks 5–6: Score controls. Gather evidence for each finding. Build the readout.
- Week 7: QA & finalization. SA reviews findings. Prepare slides.
- Daily: Flag high-risk findings to SA. No surprises in the readout.
Success criteria (you deliver)
- ✓ All controls scored (no gaps, no unknowns).
- ✓ Evidence gathered & audit trail clear.
- ✓ High-risk findings validated independently.
- ✓ Readout slides ready (data + narrative).
- ✓ SA approves before week 8 readout.
Build the system. 8 weeks. Sprint cadence.
SA designed the architecture. You code it. Build the registry, intake engine, monitoring agents, and dashboard. Test rigorously. Deploy.
Your 2-week sprints (weeks 8–15)
- Sprint 1 (w8–9): Registry schema + API. PostgreSQL setup. Baseline CRUD.
- Sprint 2 (w10–11): Intake workflow state machine + approval gates.
- Sprint 3 (w12–13): Monitoring agents + alert rules. Test extensively.
- Sprint 4 (w14–15): Dashboard implementation + styling. Tie to APIs.
- Each sprint: Code review, unit tests, integration tests, no tech debt.
Success criteria (you deliver)
- ✓ All SA design points implemented (no shortcuts).
- ✓ 80%+ code coverage (unit + integration tests).
- ✓ Zero production bugs in week 1 of operations.
- ✓ Performance targets met (API <100ms, dashboard <2s).
- ✓ Deployment plan ready. Runbook written.
Delivery wins: If you ship on day 105 with zero defects, ops ramp is smooth + client confidence is high. If you ship on day 120 or with bugs, operations explodes.
Go live. Support. Train the client. 4 weeks.
The system is live. You're on-call for month 1. You fix bugs, handle escalations, and train the client's team to run it solo.
Your ramp (weeks 16–19)
- Week 1: Go-live support (on-call, bug fixes, escalations).
- Weeks 2–4: Reduce coverage to 50%, then 20%. Client takes ownership.
- Training: 4 sessions on ops, monitoring, troubleshooting.
- Handoff: Runbook complete. Client trained. You step back.
Success criteria (you deliver)
- ✓ Zero production incidents in month 1 (you prevented them).
- ✓ Client team passes readiness assessment (trained).
- ✓ Ops runbook is complete + client approved.
- ✓ System stability confirmed (99%+ uptime).
- ✓ Clean handoff. You exit gracefully.
What you sign off on. What Sales / SA must do.
| Checkpoint | You (Delivery) | Sales | SA |
|---|---|---|---|
| Kickoff readiness | Confirms: crew ready, tools set, no blockers | Warm handoff to client team | Briefs you on discovery design |
| Discovery completion | Executes discovery, delivers inventory | — | QA's inventory, approves handoff |
| Assessment completion | Scores controls, gathers evidence | Prepares to present readout | Reviews findings, approves readout |
| Implementation design approval | Reviews: is this buildable? Do I have blockers? | — | Signs off on the architecture |
| Sprint delivery (every 2 weeks) | Code, test, integrate, deploy to staging | — | Reviews: does this match the design? |
| Go-live readiness | System is production-ready. Runbook written. Client trained. | — | Final design verification |
| Production handoff | On-call month 1. Trains client. Steps back week 4. | — | Available for ops questions |
Legend: R = Responsible (does the work) · A = Accountable (signs off) · C = Consulted (input) · I = Informed (kept in loop)
What "done" means. Zero exceptions.
For discovery
- 95%+ coverage — not 85%, not 90%. 95%+.
- Clean data — no duplicates, no junk entries, no corrupt records.
- Audit trail — every field traceable to its source (API, log, config).
- No data loss — if you drop a record, you know why + you've told SA.
For code (implementation)
- No tech debt — ship production-ready code, not scaffolding.
- 80%+ test coverage — unit, integration, and e2e tests.
- Performance targets met — API <100ms, dashboard <2s load.
- Zero production incidents w1 — if there are bugs, they're small + non-blocking.
This is not negotiable: You don't ship "good enough." You ship production systems. If you're on-call in month 1 and getting paged, you failed. If the client runs it solo in month 2 and discovers major bugs, you failed. Build right.