This is a read-only training. There is no video — take a few minutes to read through the guide below.
LeanScale Delivery Model (READ FIRST)
Action Step
Complete this before moving on.
Read the training below. Pay attention to how each ring connects to the next — this is the mental model everything else in the architect course builds on.
Use +/- or scroll to zoom into the diagram, drag to pan
The Delivery Model — Reading the Rings
Everything you learn about how LeanScale works — the projects, the systems, the meetings, the time tracking — fits into one mental model. Think of it as four concentric rings, read from the inside out. Each ring answers a different question. Together, they show how every piece of the delivery model connects.
Why Rings, Not a List
You'll hear about the 4-Phase Approach, Task Stages, Ad Hoc work, Time Logging, Sprint Meetings, EOW Recaps, Standups, Slack comms. Listed out flat, those are eight disconnected things to memorize.
The problem is they aren't eight equal things. They operate at different levels of abstraction. Some describe the work itself. Some describe the systems that organize the work. Some describe the rituals that drive the systems forward.
When you nest them in rings, you stop memorizing a list and start seeing one model.
Ring 1 — The Center: THE WORK
"What do we actually do?"
Two types of work sit at the core of everything.
Projects are scoped, defined pieces of work with a clear start and end. Things like CRM migrations, lead attribution setups, growth modeling, reporting suites, lifecycle staging, or quote-to-cash implementations. Every project follows the same four-phase delivery structure. Each one is backed by a playbook that defines exactly how to deliver it.
Ad Hoc / Managed Services covers the steady stream of operational requests that come up throughout a given day or week. Adding a new user to Salesforce, building a new report, importing a list, debugging a workflow issue. These don't follow the four phases. They come in, get scoped, get done.
Here's the key distinction: LeanScale runs two types of engagements. Project engagements are projects only — you're executing against a defined scope, no ad hoc work. Embedded engagements give the customer the whole suite — projects plus ad hoc. So if you're on an embedded engagement, you're handling both. If it's a project engagement, you're focused on delivery against that specific scope.
Most embedded clients have both running at the same time. The architect balances project work against ad hoc requests based on what gets prioritized each week in sprint.
This is the simplest, most concrete level. If someone asks "what does LeanScale actually do day to day?" — this is the answer.
Ring 2 — The Middle: THE SYSTEM
"How do we structure and track it?"
Three systems wrap around the work to give it structure. Each one answers a specific question.
The 4 Phases — "What order do we work in?"
Every project rides the same structural rails. The weight of each phase changes depending on the project — a growth model is 80% strategy, a CRM migration is 80% engineering — but the structure is always the same.
Phase 1: Strategy — get stakeholder sign-off on what to build. Pre-Kickoff homework, a Kickoff Call, an Alignment Loop to iterate on assumptions, and a Strategic Output that gets signed off. The architect walks into the kickoff with a near-complete draft and validates assumptions rather than starting from scratch. Educate the customer first — they don't always know what good looks like.
Phase 2: Engineering — build and test the system. A Tech Spec Doc translates the strategy into field mappings and workflow logic. The architect hands off to the engineer. The engineer builds. QA happens in two layers — does it work technically, and does it do what the customer needs.
Phase 3: Enablement — make sure the customer's team can operate independently. Training materials, training sessions, and a hypercare period of intensive post-launch support. This phase was historically skipped because it was manual drudgery. AI makes it feasible to generate training docs, loom scripts, and FAQ drafts from the strategic and technical documentation.
Phase 4: Handoff — clean closeout with a maintenance schedule, internal and external handoffs, and a project close. The maintenance schedule is also a retention mechanism — it future-casts what the customer will need to revisit in three months, six months, a year.
In Teamwork, each phase maps to a Milestone. Each sub-phase maps to a Task List under that Milestone. Each deliverable maps to a Task.
The phases are rails, not scripture. They use gate reviews, not gate locks — you can proceed with conditions and loop back. Structure is non-negotiable, but the content inside each phase is flexible.
Task Stages — "Where is any given task right now?"
Whether a task comes from a project or from the ad hoc bucket, it moves left to right through the same Kanban stages:
Backlog → Grooming → On Deck → In Progress → LeanScale Review → Delivered → Completed
Two step-out lanes sit alongside In Progress: Waiting on Customer (blocked on their input) and On Hold (internal blockers — use sparingly).
The key stages to understand:
- Backlog is where candidates for future work sit. The bigger the backlog, the more embedded we are. That's a good thing.
- Grooming means scope is being defined. This is where tasks get elevated from the backlog to become next week's sprint work. Exit criteria: scope is fully documented and ready for someone to execute.
- On Deck means it's in this week's sprint. Scope is complete. It has a start and end date within the current week. Aligned with the customer.
- In Progress means it's actively being worked on.
- LeanScale Review is the QA gate. The engineer finishes work, moves the task here, and the architect reviews before it goes out. Think of it like food sitting in a restaurant kitchen waiting for the server — move through this quickly.
- Delivered means done and communicated to the customer via Slack, Loom, or written format. Tasks sit here until the next sprint meeting, where they get recapped.
- Completed — after the sprint meeting recap, delivered tasks get marked complete to clear the board for the new week.
The Everything Board in Teamwork rolls up all tasks across all projects for a client into one Kanban view organized by these stages. This is the board the architect opens in every sprint meeting.
Here's the key: the 4 Phases and the Task Stages are not competing systems. The 4 Phases are the vertical structure — which milestone or phase does this task belong to? The Task Stages are the horizontal flow — where is this task in the pipeline right now? Every task has both a phase (vertical) and a stage (horizontal).
Time Logging — "How much is all of this costing?"
Hours are the economic unit. Engagements are sold as monthly hour budgets — 60, 100, 150 hours depending on the plan. Every hour you spend gets logged against a task in Teamwork.
Log at the task level whenever you can. That drives insights into how long specific types of work take, which feeds back into future scoping and time estimates. Log at least twice per day — midday and end of day — to maintain accuracy.
Three buckets of time:
- Billable (the largest bucket) — standups, sprint meetings, ad hoc client meetings, internal meetings about client work, task execution, Slack and email communications with the customer, end-of-week recaps, project management in Teamwork. If it's related to the customer, it's billable.
- Internal — one-on-ones, company meetings, internal initiatives. Logged but not billed.
- Don't log — lunch, personal breaks, appointments.
Time logging is what makes capacity management possible. It tells you whether you're on pace, over, or under for the month, and it surfaces potential overage conversations early — before the end-of-month surprise.
Ring 3 — The Outer Ring: THE RHYTHM
"When do we sync?"
The system only works if there's a consistent cadence driving it forward. Without the rhythm, the board goes stale, the customer loses visibility, and the engagement drifts.
Daily — Slack comms, ad hoc responses, and time logging. Speed matters here. If the customer gets a faster response from us than from their own teammate, they build muscle memory around coming to us first.
Weekly (Monday) — the Sprint Meeting. Thirty minutes. This is the heartbeat of every engagement and the single most important ritual at LeanScale. The architect opens the Everything Board, gives an hours update against the monthly budget, recaps everything delivered last week, walks through what's on deck this week, and gets customer alignment on priorities. If there's time, a demo or scoping discussion.
The sprint meeting has four buckets: rapport building as people join (2-3 min), recap and review of delivered work and hours (5-6 min), prioritization of this week's sprint (15-20 min — the most important bucket), and discussion and demo (5-10 min). Wrap-up recaps key decisions and commits to next steps.
Weekly (Friday) — the EOW Recap. A summary of everything delivered that week, sent to the customer. This makes sure they see the volume and value of what's getting done — because sometimes things move so fast that work gets lost. We've recently moved to an AI-automated approach for these instead of architects recording a Loom every week.
Weekly (Internal) — Standups and Sprint Jam / Prep. Before the Monday sprint, the architect preps the agenda, checks engineer capacity in the Teamwork planning view against the 8-hour daily budget, and makes sure they're not promising more than the team can deliver. Stack rank items on the board — lead with strategic project updates, not password resets. Standups keep the internal team aligned throughout the week.
Monthly — hours pacing check, reporting packs, and data audits. The customer gets either a video asset or a more detailed report covering what happened over the past month. Prevents any end-of-month surprises on budget.
Quarterly — growth model reviews, quarterly business reviews, re-running diagnostics, and scoping any projects that need maintenance or a fresh look. Step back from the tactical work and look at whether the strategic plan is still on track. Review every input into the go-to-market model, find where the biggest delta is, and recalibrate project priorities around that.
The Outermost Ring: TEAMWORK
"Where does it all live?"
Teamwork is the container. It's not a concept — it's the literal platform where everything happens. The Teamwork hierarchy mirrors the model:
- Client → the customer
- Projects → each scoped project + one "Ad Hoc / Managed Services" project per client
- Milestones → the 4 Phases (one per project, except Ad Hoc which has none)
- Task Lists → the sub-phases under each milestone
- Tasks → the individual deliverables
- Task Stages → the Kanban columns on the Everything Board
- Time Entries → logged against tasks
Every view in Teamwork maps to something in the rings. The Everything Board shows Ring 2 (task stages). The Planning View shows capacity (Ring 2 time logging). The Calendar syncs with meetings for time logging. The Clients View gives a top-down look at all active engagements and budgets.
The Sprint Meeting Is the Hub
If there's one thing to internalize from this entire model, it's this: the sprint meeting is where all four rings converge in one room.
The architect opens the Everything Board. That's the Task Stages (Ring 2). They give an hours update. That's Time Logging (Ring 2). They walk through Delivered items. Those came from Projects and Ad Hoc (Ring 1) and moved through the stages. They prioritize On Deck for the week. That sets the Rhythm (Ring 3) for the next five days. They demo completed work and discuss upcoming scoping. That's relationship-building and strategic alignment.
Every ritual in Ring 3 either feeds into the sprint meeting (Sprint Prep), happens during it (the meeting itself), or extends from it (EOW Recap, daily execution).
The end of week recaps might be hit or miss — customers are busy, they may not look at them. But the Sprint Meeting is the one guaranteed touchpoint where you move the entire engagement forward.
The Team
Two key roles run every engagement:
- Architect — main customer contact. Leads sprint meetings. Manages the board. Leads Strategy and Enablement phases. Reviews all work before delivery. Owns the customer relationship.
- Engineer — the technical counterpart. Leads the Engineering phase builds. Executes technical tasks. Manages systems and handles technical requests.
Behind them is the Center of Excellence — internal specialists brought in for gaps. No one person knows everything. When there's an edge case or a domain that needs deeper expertise, the center of excellence fills it.
The One-Liner
We do Projects and Ad Hoc work. Projects follow four phases. All tasks flow through the same Kanban stages. We sync with the customer every week in Sprint. We track time against everything. It all lives in Teamwork.
Comment in Slack
Post your answer in your onboarding channel.
What was your biggest takeaway(s) from this training?