Define the division of labor between design team and client to prevent scope creep. Apply the Plan-Define-Develop-Extend framework to structure a two-to-three page proposal. Limit commitments to deliverable outputs to protect project pricing and timeline.
Learning Objective: By the end of this lesson, learners will be able to structure a Scope of Work proposal using the Plan-Define-Develop-Extend framework.
The Scope of Work acts as a hard boundary, explicitly stating which components the design team owns versus what the client handles. It serves as a strategic constraint because it ensures the client understands the scope as well as the designer does. If you fail to define this division of labor clearly, that ambiguity will come back to haunt you later. You must limit included items to only those outputs the team can actually deliver. This strict limitation prevents revisiting project pricing or updating the document after the work has begun. By excluding vague commitments, you protect the project from scope creep and unexpected cost changes. The core function is simply to define who does what, so there are no surprises during execution. Once this boundary is set, we can look at how to structure the proposal document itself.
Key Points:
The Scope of Work (SOW) explicitly states which components the design team is responsible for versus the client.
It serves as a strategic constraint to prevent future issues by ensuring the client understands the scope as well as the designer.
Limiting included items to only deliverable outputs prevents revisiting project pricing or updating the document later.
Failure to define this boundary clearly will 'come back to haunt you' during execution.
You need to apply constraints to limit proposal length to two to three pages and exclude non-deliverable items. Keeping the document concise prevents scope creep and ensures the client understands the exact division of labor. You must include only deliverable outputs in the Scope of Work, avoiding any specifics or commitments without defining details beforehand. This strict limitation prevents future updates to the document or revisiting project pricing later on. The proposal must define the process clearly, which can be detailed or simple depending on project needs. A common approach uses the Plan-Define-Develop-Extend framework to structure the work. First, you plan the overall strategy, then define detailed project requirements, followed by developing and launching the product. Finally, you recommend enhancements based on what you learned during testing and post-launch phases. By structuring your Scope of Work this way, you align expectations between the designer and the client. You avoid vague commitments that lead to cost overruns or unclear responsibilities. The goal is to create a linear approach where definition comes first, ensuring a solid foundation before designing or deploying. This method protects both parties from misunderstandings about what is included in the final deliverable.
Key Points:
Keep the proposal document to a maximum of two to three pages.
Include only deliverable outputs; avoid specifics or commitments without defining details beforehand.
The proposal must define the process, which can be detailed or simple depending on project needs.
Strictly limit the SOW to outputs that can be delivered to prevent scope creep.
You structure the Scope of Work using a four-phase process framework that moves from high-level strategy to detailed execution. This linear approach ensures everyone understands the division of labor before any actual design work begins. The first phase is Plan, where you establish the overall strategy for the project. This sets the boundaries and aligns the team on the broader goals. It prevents scope creep by clarifying what success looks like upfront. Next, you enter the Define phase to specify the detailed project requirements. This is where you translate strategy into concrete specifications and user needs. You must define these requirements clearly to avoid ambiguity later in the process. Without this step, the development team lacks the precise instructions they need to build effectively. It bridges the gap between abstract strategy and tangible deliverables. The third phase is Develop, which involves creating, testing, refining, and launching the work product. This is the heavy lifting where the actual design and development occur. You iterate on the solution based on feedback and testing results. The goal is to refine the product until it meets the defined requirements. Launching marks the transition from internal creation to external delivery. Finally, you reach the Extend phase, where you recommend enhancements based on post-launch data. You analyze information learned during development and testing to identify areas for improvement. This phase acknowledges that a project rarely ends with the initial launch. It provides a structured way to propose future iterations and optimizations. This keeps the partnership alive beyond the immediate deliverables. By following this Plan, Define, Develop, and Extend sequence, you create a clear roadmap for the client. It transforms a vague request into a manageable series of steps. Each phase has a distinct purpose and set of deliverables. This structure protects both you and the client from misunderstandings. It ensures that the final product aligns with the initial strategic vision. This framework provides the skeleton for your proposal document. You will flesh out these phases with specific efforts and responsibilities later. But first, you need to understand how to navigate the common pitfalls that arise during execution. Knowing where things typically go wrong helps you build a more resilient project plan.
Key Points:
Plan: Plan the overall strategy for the project.
Define: Define the detailed project requirements.
Develop: Develop, test, refine, and launch the work product.
Extend: Recommend enhancements and improvements based on information learned during development, testing, and post-launch.
You must avoid making judgment calls on cost or scope before you have actually written the proposal or requirements document. The reason is simple: it is not possible to know the true cost without these foundational documents firmly in place. If you try to guess the effort now, you risk errors later in the project timeline. So when you start drafting, resist the urge to estimate based on a hunch alone. There is some wiggle room for judgment calls, but only under very specific conditions. You can rely on experience if you are working on a basic website, have completed similar projects before, or know the client well. In those cases, your past data allows for educated guesses about the timeline and budget. However, this exception does not apply to complex or novel projects where uncertainty is high. If vague commitments slip into your draft, limit the scope of work to deliverable outputs. This constraint prevents scope creep and stops the client from demanding pricing revisions later on. By focusing only on what you can physically deliver, you protect both the budget and the relationship. This discipline ensures the proposal remains a reliable contract rather than an open-ended negotiation. With those pitfalls identified, you are ready to apply the framework by detailing the specific efforts within each phase.
Key Points:
Avoid making judgment calls on cost or scope before writing the proposal or requirements document.
It is not possible to know the cost without these foundational documents in place.
Exception: There is 'wiggle room' for judgment calls if working on a basic website, with similar past projects, or with a known client.
Recovery: If vague commitments slip in, strictly limit the SOW to deliverable outputs to prevent pricing revisions.
Now you apply the framework by detailing the specific efforts within each phase, ensuring the division of labor is clear to both you and the client. You must explain exactly what those efforts mean, which aligns expectations and prevents scope creep from derailing the project later. This linear approach keeps definition first, followed by designing the experience, and finally developing or deploying the solution in a structured sequence. While the overlap between steps varies depending on the specific project approach, the underlying sequence remains consistent and reliable for managing complex work. Consider how you would describe the "Extend" phase to a client who only understands building, not long-term enhancement strategies. By strictly limiting the document to deliverable outputs, you protect the pricing and prevent the need to revisit the agreement after launch. This disciplined structure turns vague commitments into concrete deliverables that both parties can execute without confusion or unexpected costs. You have now structured a Scope of Work proposal using the Plan-Define-Develop-Extend framework, ready to apply it to your next real-world project.
Key Points:
Detail the various efforts in each phase (Plan, Define, Develop, Extend) after defining the process.
Explain what those efforts mean to both the designer and the client to align expectations.
Use the linear approach: definition first, followed by designing the experience, then developing/deploying.
Recognize that overlap between steps varies by project approach, but the sequence remains consistent.