Project Planning & Scheduling in Onplana: The Complete Tour (2026)

Project Planning & Scheduling in Onplana: The Complete Tour

This is the hands-on guide to how planning and scheduling actually work in Onplana, the tasks you create, the dependencies you draw, the views you switch between, and the way the math holds up under real-world reschedules. If you're evaluating Onplana as a Project Online or MS Project Desktop replacement, this is the post that confirms the schedule fidelity is real. If you're a new user, this is the tour.

For the wider product story, Onplana vs Microsoft Project Online: Feature-by-Feature Comparison covers everything beyond planning. For the methodology side, How to Create a Project Plan and Critical Path Method Explained cover the conceptual ground.

The project shell

Every plan in Onplana starts with a Project. The shell carries the metadata that everything underneath inherits.

Field	Purpose
Name	The display name, shown in lists and the URL slug
Status	PLANNING / ACTIVE / ON_HOLD / COMPLETED / CANCELLED
Start date / End date	Date-only fields (no timezone shifts), serialized as YYYY-MM-DD
Owner	A user who has full project rights regardless of project-role tier
Budget + currency	Optional; drives EVM math and Finance tab
Working calendar	Inherits from org default; can override per-project
Custom fields	Any organisation-defined PROJECT-scope fields
Members	Project members with per-row roles (OWNER / MANAGER / MEMBER / CONTRIBUTOR / VIEWER)
Type	OPERATIONAL or STRATEGIC (drives Score calculation when governance is enabled)

progress is auto-calculated from task completion (DONE root tasks / total root tasks * 100) and recomputes on every task mutation, so you don't manually maintain it. Manually editing it gets overwritten on the next task change.

Tasks + subtasks

Tasks are the workhorse of the plan. Every task carries:

Field	Notes
Title	Required, the headline
Status	TODO / IN_PROGRESS / REVIEW / DONE / BLOCKED, plus per-project custom statuses
Priority	LOW / MEDIUM / HIGH / CRITICAL
Start date / Due date	Date-only
Estimated hours	Numeric, drives EVM and capacity math
Progress	0-100, auto-set to 100 on DONE; safety-clamped to ≤99 on non-DONE
Assignee	One user (assignment can change without losing history)
Parent task	Optional; if set, this task is a subtask. No grand-subtasks (depth = 1)
Order	Integer position within the parent (or root if no parent)
Tags	Org-scoped, color-coded labels
Custom fields	Any organisation-defined TASK-scope fields
Milestone flag	Boolean; when true, the task renders as a diamond marker

Subtasks

A subtask is a task with parentId set. Onplana intentionally does NOT support grand-subtasks (a subtask's subtask). The reason: 80% of organisations that build deep task hierarchies regret it within a quarter when reports become unreadable; the 20% that genuinely need it usually want a separate child project instead. The two-level model (task + subtask) keeps schedules legible.

Subtasks roll their progress up to the parent's progress field automatically. Adding a subtask to a parent task immediately changes the parent's status math (parent moves to DONE only when all subtasks are DONE).

Custom statuses

The 5 default statuses cover most teams. For workflows that need more (e.g. "Awaiting Client Sign-off", "In QA"), define custom statuses on the project via Settings → Project → Custom Statuses. Stored as JSON on Project.customStatuses; tasks reference them by string. The Kanban view renders one column per defined status.

Dependencies: all four types with lag

Onplana matches Microsoft Project's dependency model exactly. Every dependency carries an explicit type and lag value.

Auto-scheduler behavior

When you create or edit a dependency, the auto-scheduler walks downstream and shifts dates as needed. If a predecessor finishes 3 days late, every FS-dependent successor moves 3 days right (preserving lag). The shift respects each task's assignee calendar, so a 3-day shift across a weekend lands 5 calendar days later for a Mon-Fri assignee.

Circular-dependency guard

A circular-dependency detector runs before every dependency create / edit. The algorithm is BFS through the dependency graph with a 500-node max (returns 'GRAPH_TOO_LARGE' beyond that). If the new dependency would create a cycle, the API returns 400 with an actionable error pointing at the offending edge. No partial writes; the dependency is rejected entirely.

Lag values

Lag is stored as integer days and applies to all four dependency types. Negative lag (lead time) is supported, e.g. "task B can start 2 days before task A finishes" (lag = -2 on FS). The Gantt renders lag as space between bars; the auto-scheduler factors it into every shift.

Critical path

Onplana computes the critical path on every project schedule with at least one dependency. The algorithm:

1. Forward pass: walk each task's early_start and early_finish accounting for predecessor early_finish + lag.
2. Backward pass: walk each task's late_start and late_finish from the project end date.
3. For each task, total slack = late_start - early_start.
4. Tasks with zero slack are on the critical path.

The Gantt view highlights critical-path tasks with a red bar so the longest schedule path is visible at a glance. Recomputed on every task / dependency mutation, so it's always current.

When the critical path changes (e.g. you add a new dependency that shifts which tasks are on the longest path), the Gantt updates without a refresh.

Milestones + baselines

Milestones

A milestone is a zero-duration task with isMilestone: true. They render as diamond markers on the Gantt timeline and on the project Dashboard's milestone widget. Use them for delivery dates, gate decisions, or external commitments that don't have effort but anchor the schedule.

Milestones can have dependencies (often Finish-to-Start with lag from the last task that must complete before the milestone fires) and are factored into the critical path calculation.

Baselines

A baseline is a named snapshot of every task's planned start, finish, and effort, captured at a moment in time. Save one when the plan is committed (e.g. "Approved at sprint planning Apr 28") and Onplana stores the snapshot. The Gantt then renders the baseline as a phantom row INSIDE the Gantt:

• The current bar shows where the task is now.
• The phantom row shows where it WAS at baseline time.
• Drift is visible as the gap between the two.

No mode switch, no separate "compare" view. Multiple baselines per project are supported (named so you can pick which one to overlay). Hover any baseline bar for the planned date and the drift in days.

Working calendars

Onplana's calendar model is two-layered: a base calendar that defines the working pattern, plus per-resource exceptions that override the base for a specific user.

Base calendars

Each org has at least one default calendar. Templates available at create time:

• Standard Mon-Fri, 8h/day
• Mon-Sat, 8h/day
• 7-day week
• Custom (pick days + hours-per-day)

Multiple base calendars per org. Common pattern: one calendar per region or contract type (e.g. "France 35-hour week", "Sun-Thu Middle East", "Part-time M/W/F").

Per-project calendar selection

When a project is created, Onplana picks up the org's isDefault calendar automatically. You can change it via Edit Project. The auto-scheduler uses the project's calendar when shifting dates.

Per-user assignment

Each user is anchored to one calendar (defaults to the org default). The auto-scheduler uses the assignee's calendar when shifting their tasks. So a 3-day FS lag from a task assigned to a Mon-Fri person to a task assigned to a Sun-Thu person produces the right shifted date for each side.

Per-resource exceptions

Vacation, sick leave, training, conference: any per-user override of the base calendar lands as a CalendarException row tied to that user, with start + end + reason. The auto-scheduler skips exception days when shifting tasks; the Capacity Planner shows reduced availability for the affected weeks.

Configure at Org Settings → Configuration → Working Calendars (admin) or in the user's profile (self-service for own vacation).

Five views on the same data

Onplana doesn't separate "the schedule" from "the board" from "the list". They're all views over the same task model, which means edits propagate instantly across views without a save-publish cycle.

When to use which

View	Use when...
List	You need bulk edits, audits, or to find tasks by filter. Power-user view; sortable by every column.
Kanban	You're running a daily standup or want flow-by-status visibility. Drag tasks between columns to update status.
Gantt	Your schedule is dependency-driven. Need to see the timeline, the critical path, baseline drift. PRO+ feature.
Calendar	Work is due-date-driven (marketing campaigns, client deliverables, content publishing). Monthly grid.
Burndown	You're running sprints and want velocity / projected-completion. Per-sprint view + project-level "All tasks" view.

The view-switcher is always at the top of the project. Switching is instantaneous (no data refetch, no loading spinner) because all views consume the same in-memory task list.

Sprints, Epics, and Backlog (Agile)

For Agile teams (PRO+).

Sprints

A sprint is a time-boxed iteration with startDate, endDate, and a list of assigned tasks. The full lifecycle is PLANNING → ACTIVE → COMPLETED. The Sprint board shows the assigned tasks grouped by status (the Kanban view, scoped to the sprint).

Per-sprint Burndown chart with:

• Ideal burndown (dashed line, straight from start scope to zero)
• Actual burndown (solid, computed from per-day DONE counts)
• Velocity (tasks/day or hours/day)
• Projected completion date

Sprint scope is the set of tasks where task.sprintId == sprint.id. Move a task in/out of a sprint by editing it or by drag-and-drop from the Backlog.

Epics

An epic is a thematic grouping of related work that may span multiple sprints (e.g. "Q3 Onboarding Redesign", "Customer Trust Initiative"). Tasks carry an optional epicId; the Backlog view groups by epic for easy planning. Epics have their own color so the Gantt can be tinted by epic.

Backlog

The Backlog view shows all tasks that aren't yet assigned to a sprint, grouped by epic (or by parent task / by no-grouping). Bulk select + move-to-sprint is the main planning interaction. The Backlog is where Sprint Planning happens.

Recurring tasks

For work that repeats on a cadence (weekly status report, monthly compliance review, quarterly board prep), Onplana supports rule-based recurring tasks. Define the rule once (frequency, interval, days-of-week, end condition) and a background worker materializes new task instances on schedule.

The materialised tasks are real Task rows, so they carry assignees, due dates, custom fields, and dependencies independently. Updating the recurrence rule changes future instances; past instances are preserved.

AI assistance

Two paths for AI-assisted planning.

AI Project Kickstart (first-run flow)

New users on /onboarding step 3 see the AI Project Kickstart. Paste a one-paragraph project brief ("we're launching a customer feedback portal in 8 weeks; needs design, frontend, backend, integrations") and Onplana's AI returns:

• A project shell (name, suggested dates, type)
• An epic structure (high-level workstreams)
• Tasks under each epic (with estimated hours)
• Subtasks under tasks (where the AI thinks they're useful)
• Predecessor/successor dependencies (typed FS/SS/FF/SF)
• Risk candidates pre-populated for the Risks tab

Click "Use this plan" and the entire structure lands as a real project in one transaction. Edit anything from there.

AI plan generation (existing projects)

For existing PRO+ projects, the same kind of brief-to-tree expansion is available from the project's AI panel. Useful for adding a new workstream to an existing plan without manually typing each task.

Both use Onplana's AI tool catalog (function calling) so the output is structured (not free-text) and lands cleanly in the database. Detailed in A Day in the Life of an AI Project Manager.

Migration: bringing your existing schedules in

If you have existing schedules in Microsoft Project Online or .mpp files, the planning structure described above is what they land in.

From	Method	Mapping
.mpp (Project Desktop / Online export)	Drag-and-drop	Tasks + dependencies + baselines + custom fields + resources
Project Online OData (whole tenant)	Settings → Import → Project Online	Projects + tasks + assignments + resources + custom fields + lookup tables + calendars
Microsoft Planner	Microsoft Graph wizard	Tasks + buckets (as epics) + assignees
Project for the Web Premium	Dataverse path	Tasks + dependencies + effort + resources
CSV / Excel	Bulk import	Tasks (manual dependency reconnection)

The mapping is documented in How to Migrate from Microsoft Project Online. For the two technical sub-systems that drive most migration labor, see Project Online Custom Fields Migration and Project Online Resource Pool Migration.

Quick patterns

A handful of patterns that come up often enough to be worth naming:

Pattern: pilot project structure

Create a pilot project with 5-10 root tasks, each with 2-3 subtasks. Add 3-4 dependencies (mostly FS, one SS or FF for variety). Save a baseline named "Pilot kickoff". Switch between List, Kanban, Gantt, Calendar to confirm the data feels right in each view. This is the standard 30-minute evaluation flow.

Pattern: phased rollout schedule

Split the work into 3-4 epics representing phases. Each epic gets a Sprint or two. Critical milestones (gate decisions, go-live) are captured as Milestones. Save a baseline at each phase boundary so drift is visible across phases.

Pattern: dependency-heavy schedule

Author the dependency structure in List view (which has a dedicated Dependencies column). Switch to Gantt to visually verify the critical path looks right. Edit dependencies on the Gantt by drag-connecting bars when you spot reordering.

Pattern: regional team coordination

Create per-region calendars (Mon-Fri-EU, Sun-Thu-ME, custom-APAC). Assign each team member to their regional calendar. The auto-scheduler now produces shift dates that respect each side's working pattern; over-allocation detection accounts for regional non-working days.

Get started

Start free →: no card, full planning features on the FREE tier.

For a guided first-time tour, the AI Project Kickstart at /onboarding is the fastest way to land a real plan. For migration from Project Online, drag a .mpp into the migration wizard and the tasks + dependencies + baselines come across automatically.

Related reading

• Onplana vs Microsoft Project Online: Feature-by-Feature Comparison: full product comparison
• How to Create a Project Plan: Step-by-Step Guide: methodology, tool-agnostic
• Critical Path Method (CPM) Explained: the math behind the Gantt highlighting
• What Is a Gantt Chart: Gantt fundamentals
• Discipline of Goals, Milestones, and Status Reporting: how milestones fit the wider PM workflow
• Work Breakdown Structure Guide: the WBS that informs your task hierarchy
• Day in the Life of an AI Project Manager: AI plan generation deeper dive
• How to Migrate from Microsoft Project Online: bringing existing schedules in
• 7 Hidden Killers in Most MS Project Schedules: diagnostic to run on existing schedules before you migrate

---

Want a guided walkthrough of any specific feature in this post? Get in touch or just sign up free and follow the AI Project Kickstart for a 5-minute tour.