Task Dependencies

Task dependencies are relationships between tasks that determine the order in which they must be completed. Setting up proper dependencies is critical for renovation projects, where many activities must follow a specific sequence.

• Logical sequencing:

  Ensure tasks happen in the correct order (e.g., demolition before new construction).

• Preventing rework:

  Avoid situations where completed work must be undone to accommodate missed steps.

• Resource optimization:

  Allow team members to understand when they can start their work, preventing wasted time waiting for prerequisites.

• Realistic scheduling:

  Create timelines that reflect the actual sequence and duration of work.

• Risk management:

  Identify critical path tasks that directly impact your completion date.

Home Renovation Pro supports four standard types of task dependencies, each serving different scheduling needs:

1. Finish-to-Start (FS) - Most Common

• Definition:

  Task B cannot start until Task A is finished.

• Example:

  "Install drywall" cannot start until "Electrical rough-in inspection" is complete.

• Visual representation:

  Task A ——> Task B

• When to use:

  This is the most common dependency type and should be your default choice for sequential tasks.

2. Start-to-Start (SS)

• Definition:

  Task B cannot start until Task A has started (but they can run in parallel).

• Example:

  "Painting walls" cannot start until "Painting ceiling" has started (but they can overlap).

• Visual representation:

  Task A ⇢ Task B (running in parallel)

• When to use:

  Use for tasks that can be performed simultaneously but where one should begin first for logical or resource reasons.

3. Finish-to-Finish (FF)

• Definition:

  Task B cannot finish until Task A has finished.

• Example:

  "Final cleanup" cannot finish until "Touch-up painting" is finished.

• Visual representation:

  Task A ⇠ Task B (end together)

• When to use:

  Use when tasks can run in parallel but must be completed around the same time, often for coordination of final details.

4. Start-to-Finish (SF) - Least Common

• Definition:

  Task B cannot finish until Task A has started.

• Example:

  "Temporary kitchen setup" cannot finish until "Kitchen renovation" has started.

• Visual representation:

  Task A ⟵ Task B

• When to use:

  This is the least common dependency type, typically used for transition activities or handoffs between phases.

Additional Dependency Options

• Lead time:

  Makes a dependent task start earlier than it normally would. For example, a 2-day lead time on a FS dependency means Task B starts 2 days before Task A finishes.

• Lag time:

  Adds waiting time between tasks. For example, a 3-day lag on a FS dependency means Task B starts 3 days after Task A finishes (useful for drying or curing times).

• Soft dependencies:

  Preferred but not mandatory relationships. These are used as guidelines but can be overridden if needed.

• Hard dependencies:

  Non-negotiable relationships that must be respected for technical, safety, or logical reasons.

Follow these detailed steps to create dependencies between your renovation tasks:

Creating Dependencies When Adding a New Task

1. Start creating a new task:

   Begin the standard task creation process as outlined in the "Adding Tasks" guide.

2. Locate the Dependencies section:

   In the task creation form, find the "Dependencies" field (typically after the date and assignee fields).

3. Click "Add Dependency":

   This will open the dependency configuration panel.

4. Select the predecessor task:

   Choose the task that must be completed (or started) before this new task.

   • You can search for tasks by name
   • Filter by category or phase
   • Sort by date or other properties
5. Choose the dependency type:

   Select the appropriate relationship (FS, SS, FF, or SF) from the dropdown menu.

6. Set any lead or lag time (optional):

   If needed, specify how many days of lead time (overlap) or lag time (delay) should exist between the tasks.

7. Add a note (optional but recommended):

   Briefly explain why this dependency exists, especially if it's not obvious.

8. Click "Add" to create the dependency:

   The dependency will be added to your task.

9. Add multiple dependencies if needed:

   Repeat the process if the task depends on more than one predecessor.

10. Complete task creation:

    Finish adding other task details and save the new task.

Adding Dependencies to Existing Tasks

1. Open the task details:

   Click on the task you want to modify to open its detail view.

2. Find the Dependencies section:

   Scroll to or expand the Dependencies section of the task detail view.

3. Click "Add Dependency":

   Follow the same process described above to select predecessor tasks.

4. Save your changes:

   Confirm the new dependency configuration.

Using the Visual Dependency Tool

For more complex dependency networks:

1. Switch to Gantt view:

   In the Tasks section, click the Gantt chart icon to view tasks on a timeline.

2. Enable dependency mode:

   Click the "Link Tasks" button in the Gantt view toolbar.

3. Create dependencies visually:

   Click and drag from one task bar to another to create a dependency.

4. Configure the dependency type:

   In the popup dialog, select the dependency type and any lag or lead time.

5. Save the configuration:

   Confirm your settings to create the dependency.

These typical dependency sequences for renovation projects can serve as templates for your task planning:

Kitchen Renovation Dependency Chain

1. Design and planning phase:

   Measurements → Design concepts → Final plans → Material selections → Order materials

2. Preparation phase:

   Permit application → Material delivery → Set up temporary kitchen → Utility shutoff

3. Demolition phase:

   Remove appliances → Remove cabinets → Remove countertops → Remove flooring → Remove backsplash → Wall demolition (if applicable)

4. Rough-in phase:

   Framing changes → Plumbing rough-in → Electrical rough-in → HVAC modifications → Rough-in inspections

5. Finishing phase:

   Drywall installation → Drywall finishing → Primer and paint → Cabinet installation → Countertop installation (typically 1-2 day lag after cabinets) → Backsplash installation → Flooring installation

6. Final phase:

   Appliance installation → Fixture installation → Final electrical connections → Final plumbing connections → Final inspections → Cleanup

Bathroom Renovation Sequence

1. Demolition sequence:

   Remove accessories → Remove fixtures → Remove vanity → Remove shower/tub → Remove flooring → Remove wall coverings

2. Construction sequence:

   Framing → Plumbing rough-in → Electrical rough-in → Inspection → Shower pan installation → Cement board installation → Waterproofing → Tile installation (2-day lag for mortar set) → Grout application (1-day lag for tile set) → Sealer application (1-day lag for grout dry)

3. Fixture sequence:

   Vanity installation → Countertop installation (1-day lag) → Sink installation → Toilet installation → Shower fixtures installation → Final plumbing connections → Electrical fixtures installation

Flooring Replacement Dependencies

1. Remove furniture → Remove existing flooring → Subfloor inspection and repair → Subfloor preparation → New flooring acclimation (2-3 day lag) → Underlayment installation → Flooring installation → Trim installation → Furniture replacement

Interior Painting Dependencies

1. Furniture removal → Wall preparation → Ceiling painting (Start-to-Start with wall preparation) → Primer application (1-day lag after preparation) → First coat (1-day lag after primer) → Second coat (1-day lag after first coat) → Trim painting (can have Start-to-Start with second coat) → Touch-ups (1-day lag after trim) → Cleanup and furniture replacement

Maintaining and adjusting dependencies throughout your project is key to adapting to the inevitable changes that occur during renovations:

Reviewing Your Dependency Network

• Regular dependency audits:

  Schedule weekly reviews of your task dependencies to ensure they still reflect your project reality.

• Visualize the critical path:

  In Gantt view, use the "Show Critical Path" feature to highlight the chain of dependent tasks that determines your project end date.

• Check for missing dependencies:

  Look for tasks that should have relationships but don't, which could lead to scheduling conflicts.

• Validate with contractors:

  Review dependency sequences with your contractors to ensure they align with their work methods and requirements.

• Generate dependency reports:

  Use the "Dependency Report" feature to get a comprehensive list of all task relationships for review.

Handling Schedule Changes

• When a task is delayed:

  Update the task duration or end date. The system will automatically adjust all dependent tasks.

• When reordering tasks:

  Modify the dependencies first, then update the task dates to maintain proper sequencing.

• Fast-tracking options:

  To compress the schedule, consider changing some Finish-to-Start dependencies to Start-to-Start where tasks can safely overlap.

• Handling unexpected discoveries:

  When unforeseen work is identified, add the new tasks and immediately establish their dependencies to understand schedule impacts.

Resolving Dependency Conflicts

• Circular dependencies:

  The system will alert you if you create a circular reference (Task A depends on Task B, which depends on Task A). Resolve this by removing one dependency or rethinking the task structure.

• Scheduling impossibilities:

  If dependencies create an impossible schedule (like requiring more time than available), use the "Schedule Analysis" tool to identify and resolve conflicts.

• Resource conflicts:

  When the same person is assigned to concurrent tasks due to dependency shifts, use the "Resource Conflict" detector to identify and resolve overlaps.

• Dependency violations:

  If team members begin tasks before prerequisites are complete, use the dependency notification system to alert them of the correct sequence.

Optimizing Your Dependency Network

• Identify bottlenecks:

  Look for tasks with multiple dependents that could delay many subsequent tasks if they run late.

• Build in buffers:

  Add appropriate lag time to dependencies involving uncertain outcomes or external factors.

• Simplify overly complex chains:

  Sometimes a long chain of dependent tasks can be simplified by focusing only on the essential relationships.

• Find parallelization opportunities:

  Look for tasks that could run concurrently to compress the schedule without compromising quality or safety.

• Document dependency decisions:

  Add notes explaining why important dependencies exist, especially for unusual relationships that might be questioned later.