How to Apply Basic Constraints in Microsoft Project

When you first start using Microsoft Project, it can feel like the software has a mind of its own. You enter tasks, add dates, link a few things together… and suddenly the schedule changes in ways you didn’t expect.

A big part of controlling your plan is understanding constraints.

Constraints tell Microsoft Project how flexible each task is. They answer questions like:

• Does this task have to start on a certain date?
• Can this task start any time after a specific date?
• Is there a latest date it should start or finish?

In this guide, we’ll walk through:

• What constraints are and how they affect your schedule
• The different basic constraint types in Microsoft Project
• How to apply constraints step by step
• When to use constraints (and when not to)
• How to fix common problems with constraints

The aim is to keep the language simple, while still giving you enough detail to use constraints confidently in real projects.

1. What Are Constraints in Microsoft Project?

By default, Microsoft Project wants to help you build a flexible schedule.

If you create a new project and start entering tasks, Project will usually:

• Schedule tasks as soon as possible after the project start date
• Adjust task dates automatically when you change:
  • Durations
  • Dependencies (links between tasks)
  • Calendars (working/non-working days)

This is great because you don’t have to manually change dates all the time.

However, real projects often have rules like:

• “The training day must start on 10 March.”
• “The software launch can’t happen before the marketing campaign.”
• “The supplier will deliver no earlier than the 15th.”

That’s where constraints come in.

A constraint is a rule you apply to a task to control how Project can schedule it. Instead of letting the task float freely based only on dependencies, you give Project a condition it must respect.

2. Constraints vs Deadlines

Before we go further, it’s important to understand the difference between:

• Constraints – They control when tasks can start or finish. They can restrict the schedule.
• Deadlines – They do not control dates; they simply give you a target date and show a warning if the plan slips past it.

A simple way to remember:

• Use constraints to say “this task must/can’t happen at this time.”
• Use deadlines to say “we want this task done by this date, but let Project move it if needed.”

For basic scheduling, especially when you are still getting used to Microsoft Project, it’s often better to:

• Use dependencies and calendars first
• Use deadlines to monitor important dates
• Only add constraints when there is a genuine business reason

We’ll talk more about best practices later.

3. The Main Constraint Types (Explained Simply)

Microsoft Project has several constraint types. You don’t have to use them all, but it’s useful to understand the most common ones.

Flexible constraints (no fixed date)

These are the default types:

• As Soon As Possible (ASAP) – The task starts as early as it can, based on predecessors and calendars.
• As Late As Possible (ALAP) – The task is pushed as late as possible without delaying the overall project.

For most projects:

• If your project is scheduled from a start date, tasks use ASAP by default.
• If your project is scheduled from a finish date, tasks use ALAP by default.

These constraints are fully flexible – they don’t force a specific date.

Common “basic” date constraints

These constraints tie a task to a particular date but still allow some flexibility:

• Start No Earlier Than (SNET)
  The task cannot start before a given date, but it can start later if needed.

Example: Training can’t start before 1 September because the room is not available.

These are often classed as “semi-flexible” constraints. You give Project a boundary, but it can still move the task within that limit based on other logic.

Hard (inflexible) constraints

These constraints lock the task to a specific date:

• Must Start On (MSO)
  The task has to start on the date you set.
• Must Finish On (MFO)
  The task has to finish on the date you set.

Use these sparingly. They remove a lot of flexibility from your schedule and can lead to conflicts if your plan changes.

4. Where to See Constraints in Microsoft Project

Before you start changing constraints, it helps to know where they live.

Constraint Type and Constraint Date fields

In the Gantt Chart view:

1. Right-click on any column heading (for example, “Start” or “Finish”).
2. Choose Insert Column.
3. Select Constraint Type.
4. Repeat and insert Constraint Date if you want to see the associated date.

Now, for each task, you can see:

• What constraint type is applied (ASAP, SNET, MSO, etc.)
• The constraint date, if there is one

This makes it much easier to:

• Spot tasks with fixed dates
• Review constraints applied by other people
• Troubleshoot scheduling issues

Constraint indicators

In the Indicators column (usually the first column with small icons), you may see symbols that indicate constraints or schedule warnings.

If you hover over these icons, you’ll often see helpful messages, such as:

• “This task has a ‘Start No Earlier Than’ constraint.”
• “The task is scheduled to start on a date later than its constraint.”

This is useful when you’re trying to work out why a task won’t move the way you expect.

5. How to Apply a Basic Constraint (Step by Step)

Let’s walk through applying a basic constraint using the Task Information dialog, which is one of the clearest ways for newer users.

Example scenario

Imagine you are planning a small project and you have a task called:

“Client review meeting”

You know that:

• The client is only available from 15 March onwards.
• You don’t want this meeting to appear earlier in the plan.

This is a perfect case for a Start No Earlier Than constraint.

Applying the constraint via Task Information

1. In the Gantt Chart view, locate the task “Client review meeting”.
2. Double-click the task name (or right-click and choose Information).
3. In the Task Information dialog, go to the Advanced tab.
4. Find the Constraint Type drop-down list.
5. Change the constraint type to Start No Earlier Than.
6. In the Constraint Date box, select 15/03/20XX (use your real year).
7. Click OK.

Microsoft Project will now:

• Keep this task on or after 15 March
• Still respect any predecessors you’ve set
• Move the task later if needed, but not earlier than that date

6. Applying Constraints Directly in the Gantt Table

If you’re comfortable working with columns, you can apply constraints without opening the Task Information dialog.

Using the Constraint Type column

1. Insert the Constraint Type and Constraint Date columns (if you haven’t already).
2. For the task you want to constrain, click in the Constraint Type cell.
3. Choose your constraint from the drop-down list (e.g. Start No Earlier Than).
4. In the Constraint Date cell, enter the date you want.

This method is quick when you want to:

• Update several tasks in a row
• Review and adjust constraints across your whole project

7. Choosing the Right Constraint for Real-World Situations

Here are some simple examples of when to use each basic constraint type.

Start No Earlier Than (SNET)

Use when: The task depends on an external date and must not start before it.

Examples:

• “External audit” – the auditors only arrive from a certain date.
• “Site access granted” – you can’t start site work before the building is open.

Finish No Earlier Than (FNET)

Use when: The task can’t finish before a particular date.

Example:

• “Service contract active” – perhaps a support contract that must run for at least six months before any closure.

This is less common in everyday schedules but it can be useful for contractual tasks.

Start No Later Than (SNLT) / Finish No Later Than (FNLT)

Use when: You want to make sure a task does not drift too far into the future.

Examples:

• “Submit funding application” – must start before or on a certain date.
• “Complete draft business case” – must finish by a date agreed with stakeholders.

In practice, many project managers prefer to use:

• A flexible constraint (ASAP)
• A deadline to monitor the target date

…because hard “no later than” constraints can create conflicts if there are delays elsewhere.

Must Start On (MSO) / Must Finish On (MFO)

Use when: There is an absolutely fixed date that cannot move.

Examples:

• A live event with a fixed start date (e.g. a conference opening).
• A regulatory deadline that you must meet.

Use these with care. If too many tasks have “Must Start On” or “Must Finish On”, your schedule becomes very rigid and hard to update when reality changes.

8. Constraints vs Dependencies – Which Should You Use?

A common mistake is to use constraints when you really need dependencies.

When to use dependencies

Use dependencies (links such as Finish-to-Start) when a task’s timing is driven by another task.

Examples:

• “Test the software” depends on “Develop the software”.
• “Send launch email” depends on “Approve marketing content”.

If a task’s date is based on another task, link them instead of forcing dates with constraints.

When to use constraints

Use constraints when the timing is driven by something outside the project plan, such as:

• External suppliers
• Regulatory dates
• Fixed events (like a conference or public launch)
• Contracts and service agreements

A healthy schedule usually has:

• Most tasks using ASAP (or ALAP if scheduled from a finish date)
• Logical dependencies between tasks
• A small number of constraints where there are real external limits
• Deadlines to track important completion dates

9. Using Deadlines Alongside Constraints

Deadlines are often a better choice than rigid constraints when you simply want to be alerted if a task may finish too late.

Adding a deadline

To add a deadline:

1. Double-click the task.
2. Go to the Advanced tab.
3. In the Deadline field, select the date you want.
4. Click OK.

If the task’s finish date goes past the deadline, Microsoft Project will:

• Show an indicator in the Gantt Chart (usually a green arrow for the deadline and a warning icon if it’s missed).
• Help you see which tasks are at risk, without locking the schedule.

This allows Project to do what it does best: adjust the schedule based on dependencies and calendars, while still highlighting risks for you.

10. Fixing Common Problems with Constraints

It’s easy to end up with “messy” constraints, especially if several people have edited the plan or if you imported data from Excel or another system.

Here are some common issues and how to fix them.

Tasks that won’t move when you change predecessors

Symptoms:

• You change a predecessor’s date, but the dependent task doesn’t shift as expected.
• You see a warning icon in the Indicator column.

Possible cause:

• The task has a hard constraint like Must Start On or Start No Earlier Than set to a fixed date.

How to fix:

1. Insert the Constraint Type and Constraint Date columns.
2. Check the constraint for the task.
3. If needed, change the constraint back to As Soon As Possible and remove or adjust the constraint date.

Too many tasks pinned to specific dates

Symptoms:

• You’re constantly fighting Project to update dates.
• The schedule doesn’t react well when the project start date or durations change.

Possible cause:

• Many tasks have date-based constraints instead of using dependencies.

How to fix:

1. Filter or sort by Constraint Type to find tasks with non-default constraints.
2. Review each task:
   • If the date is truly fixed, keep the constraint.
   • If not, change it back to ASAP and use predecessors instead.

Constraints caused by manual edits

Sometimes, when tasks are manually dragged on the Gantt Chart or dates are typed in without thinking, constraints can be applied behind the scenes.

Tip:

• Get into the habit of setting predecessors and calendars first, and only then adjusting dates if there is a real external reason.
• Avoid dragging tasks unless you understand how it affects the constraint type.

11. A Simple Example: Building a Small Project Plan with Constraints

Let’s walk through a short example using a basic project.

Create the tasks

Imagine you’re planning a short internal training project:

1. Plan training content
2. Book training room
3. Deliver training session
4. Collect feedback

Add durations and links

• Plan training content – 3 days
• Book training room – 1 day
• Deliver training session – 1 day
• Collect feedback – 1 day

Set dependencies:

• “Book training room” can happen after “Plan training content” (Finish-to-Start).
• “Deliver training session” depends on both “Plan training content” and “Book training room”.
• “Collect feedback” depends on “Deliver training session”.

At this point, all tasks use ASAP and Project will schedule them as early as possible.

Add a fixed date for the training session

Your HR team confirms:

“The training must happen on 10 October.”

Here you have a choice:

• Use a Must Start On constraint on “Deliver training session”, or
• Use Start No Earlier Than + adjust the plan so it naturally lands on that date.

For a strictly fixed date, you might choose Must Start On:

1. Double-click “Deliver training session”.
2. Go to Advanced.
3. Set Constraint Type to Must Start On.
4. Set Constraint Date to 10/10/20XX.
5. Click OK.

Now, Project will keep the training session on that date, even if predecessors change (though you may see warnings if the plan becomes unrealistic).

Add a constraint for booking the room

The room bookings team tells you:

“We cannot take bookings before 1 September.”

This is a classic Start No Earlier Than case.

1. Double-click “Book training room”.
2. Go to Advanced.
3. Set Constraint Type to Start No Earlier Than.
4. Set Constraint Date to 01/09/20XX.
5. Click OK.

Now, Microsoft Project will:

• Keep “Book training room” on or after 1 September.
• Keep “Deliver training session” on 10 October.
• Adjust “Plan training content” and “Collect feedback” as needed.

You now have a simple plan that respects both:

• Real-world limitations (room booking and training date).
• Logical relationships between tasks.

12. Building Your Skills Further

In this article, we’ve focused on how to apply basic constraints in Microsoft Project and how to use them safely, without making your schedule too rigid.

In real projects, task constraints sit alongside other important features, such as:

• Creating and structuring tasks, milestones, and dependencies
• Working with auto-scheduled tasks and resolving scheduling conflicts
• Setting deadlines and baselines to track progress
• Using advanced scheduling tools, critical path analysis, resource levelling, and reporting

If you’d like structured, hands-on practice with guidance from an experienced trainer, you may find it helpful to join one of ExperTrain’s 1-day Microsoft Project courses. There are live online public dates and private options for teams at introduction, intermediate, and advanced levels, all delivered with practical exercises so you can apply what you learn straight away.

‍