One set of work, rendered as a board, a Gantt, a calendar, a spreadsheet, a workload chart, or a live dashboard, whichever your team thinks in. Tasks with dependencies and custom fields, agile sprints with burndown, milestones and roadmaps, time tracking and capacity, plus no-code automation that runs the busywork. The whole delivery stack in one console, not six tabs.
Every project your team touches lives on one record · one-time builds, ongoing retainers, agile sprints, waterfall phases, and client engagements. Health, goals, owners, deadlines, and the work itself all hang off the project, so you steer the portfolio instead of chasing scattered task lists.
The portfolio view rolls up every project across every workspace into a single, sortable surface. Group by owner, health, type, or deadline. Switch between list, grid, and board without losing your filters. You stop opening twelve plans to answer one question and start steering the whole book of work at a glance.
Every project carries a health signal computed from scope, schedule, budget, and open blockers. Set it by hand or let AI Assist roll it up from the underlying work. Each status comes with a short narrative so a stakeholder reading the board understands not just that a project is amber, but exactly what tipped it and what recovers it.
Set objectives and key results, then link the projects and tasks that actually move them. Progress rolls up automatically from the linked work, so a goal is never a stale slide · it reflects exactly where execution stands today. Everyone sees how their tasks ladder up to the outcomes leadership cares about.
Agile sprint board · 2-week cadence
Sprints & velocity2-week
Story pointsFibonacci
Backlog & boardSwimlanes
Gantt phasesWaterfall only
No two projects run the same way, so each one picks the model that fits. Spin up an agile board with sprints and velocity, a waterfall plan with phased milestones, an ongoing retainer with rolling cadence, a one-time delivery, or a client engagement with its own portal. The features that do not apply simply switch off, so the workspace stays clean.
Every project across every team rolls up to one sortable, filterable surface.
Red, amber, green on every project, computed from scope, schedule, and blockers.
OKRs link to the projects and tasks that move them, so progress is always real.
Agile, waterfall, ongoing, one-time, or client · each project picks its own model.
AI Assist summarizes each project into a narrative leadership can read in seconds.
One view engine the whole team learns once, used across every Ligna console.
Filter by status and type, switch list, grid, or board, and act in bulk · archive, change owner, set health, or export. The same browser-chrome list view powers every console in Ligna, so your team learns it once and reads it everywhere.
Status, type, owner, and date range narrow 24 projects to the 3 you need.
Flip the whole portfolio between three views without losing your filters.
Every row shows percent complete, owner, team size, deadline, and status.
Select many projects, then reassign, set health, archive, or export in one click.
Agile, client, ongoing, or waterfall is readable on every row, no drill-down.
Right-click or the kebab opens the same actions you get in the bulk bar.
One executive view rolls up on-time delivery, team utilization, at-risk count, and velocity, then lists every project with a RAG health chip, owner, deadline, and progress. AI Assist drafts the narrative status report so your Monday update is read, not written.
Track the percentage of projects hitting their committed dates, trended over time.
See how loaded the team is so you can rebalance before anyone burns out.
Red, amber, green chips make the at-risk projects impossible to miss.
Average completed points per sprint, rolled up across every agile project.
AI Assist drafts the weekly status report from the live portfolio data.
Send the auto-summarized report to stakeholders without writing the update.
Set an objective, define its key results, and link the projects and tasks that drive them. Progress rolls up from real execution, so every goal shows exactly where it stands today · never a stale quarterly slide.
Define each objective with 2-5 measurable key results and their own targets.
Connect the projects and tasks that drive each key result, by the dozen.
Each bar fills from the completion of its linked work, never hand-entered.
An on-track or at-risk chip per goal mirrors the health of its projects.
Run quarterly OKRs or any cadence, each with owners and check-ins.
Everyone sees how their tasks ladder up to the outcomes leadership tracks.
The same tasks render as a board, a Gantt, a calendar, a table, a workload chart, or a dashboard. Change a due date on the board and the Gantt bar slides · close a task in the table and the burndown drops. One task list, six ways to see it, always in sync.
Every task is a card, every column is a status, every drag updates the record. Columns come from your workspace's own status set, so a marketing board and an engineering board can read completely differently while sharing the same engine. The AI agent can re-stage stale cards on request.
Bars span the dates each task occupies. Dependency arrows show what blocks what, the milestone diamond marks the date that matters, and the today line tells you instantly whether you are ahead or behind. Drag a bar end and the new dates save instantly.
Tasks land on their due date, milestones flag the dates the business cares about, and sprints stretch across as multi-day bars. Drag a task to a new day and the due date moves. Month, week, or day, the same events render every way your team reads a calendar.
For the people who think in rows. Sort by any column, edit a cell in place, bulk-select to re-assign, and let the footer roll up the numbers, summing estimates so capacity planning stops being a guess. It is the exact same data the board and Gantt draw from, just denser.
Drag cards across your own custom statuses. WIP counts surface overload instantly.
Bars, dependency arrows, milestone diamonds, and a today line on one timeline.
Due dates, milestone flags, and multi-day sprint bars on a month grid.
Inline-edit, sort, and roll up estimates in a dense spreadsheet grid.
Scheduled hours against each person's capacity, over-allocation flagged red.
KPI heroes plus trend, status, burndown, and workload charts on one canvas.
The Kanban view: every task a card, every column a status from your workspace's own set. Drag to advance, and the record, the timestamp, and every other view update with it. Counts in the column header keep work-in-progress honest.
Move any card between statuses. The record, timestamp, and history update on drop.
Columns come from your workspace's own status set. Name, color, and order them.
Set a cap per column so a stage flags the moment it is overloaded.
Each card carries its owner avatar, label pill, due-date chip, and priority pip.
Narrow to one assignee, one label, or one sprint without leaving the view.
“Three cards sat in QA for a week. Want me to nudge their owners and flag the blockers?”
Bars span the days each task occupies. Dependency arrows show what blocks what, the milestone diamond marks the date that matters, and a today line tells you instantly whether you are ahead or behind. Drag a bar and the new dates save straight back.
Drag a bar or its edges and the new start and end save automatically.
Finish-to-start links draw between bars. Move a blocker and dependents shift with it.
Key dates render as diamonds right on the timeline.
A live vertical marker shows exactly where now sits against every bar.
Zoom the timeline from a single sprint out to the whole quarter in one click.
The chain of dependent tasks that sets the finish date is highlighted end to end.
Tasks land on their due date, milestones flag the dates that matter, and sprints stretch across as multi-day bars. Drag a task to a new day and the due date moves. The same events the board and Gantt draw from, laid out the way calendars read.
Every task with a deadline shows on the day it is due, color-dotted by type.
Key dates stand out in orange across the grid.
Sprints span as multi-day bars start to end.
Move a task to a new day and its due date updates everywhere at once.
Zoom from the whole month down to a single day with a Today jump.
Pipe the calendar to any external client so deadlines show up where your team already lives.
For the people who think in rows. Sort by any column, edit a cell in place, bulk-select to re-assign, and let the footer roll up the numbers. The same tasks the board and Gantt draw from, just denser and faster to scan.
Click any cell to edit it in place. The footer rolls up the column: total estimate across these 6 tasks is 54h.
Change status, owner, due date, or estimate right in the row. No detail round-trip.
The footer sums estimates and counts by status so capacity stops being a guess.
Order by due date, priority, estimate, or progress. Multi-sort holds two keys.
Check rows and re-assign, set status, or move a sprint in a single action.
A mini-bar per row shows percent done without opening a single task.
Pull the current filter set to CSV mapped to your columns for any handoff.
The same tasks, summed by person and day. Scheduled hours stack against each person's daily capacity, and any day over the line turns red. Re-balance before the week starts instead of explaining the slip after it ends.
Scheduled task hours sum by assignee so the whole week reads in one glance.
Any day above a person's capacity turns red before it becomes a missed deadline.
A running percentage shows who is slammed, who is balanced, and who is free.
Move a task to a lighter day or a freer teammate and the bars recalculate live.
Set each teammate's daily hours so part-timers and full-timers measure fairly.
“S. Tran is at 105% Tue and Wed while A. Osei sits at 45%. Want me to shift two tasks?”
The same tasks, rolled into the numbers leadership asks for. On-time delivery, throughput this week, open work, cycle time, plus a completion trend, a status split, a sprint burndown, and a per-person load. One canvas, drawn live from your tasks.
On-time delivery, throughput, open work, and cycle time, each with its trend.
Tasks closed per week so you can see whether the team is speeding up or stalling.
A live donut of where the work sits across every status in your set.
Remaining work against the ideal line so a slipping sprint shows on day two.
Open tasks per person, so the dashboard and the workload view tell one story.
Add, drop, and rearrange widgets so every project gets the dashboard it needs.
Break a deliverable into subtasks and checklists, wire up dependencies so the schedule shifts itself, model any data with custom fields, and run the exact statuses and priorities your team works in. One task record carries assignee, dates, estimate, labels, comments, and attachments · everything in one place.
Every task can hold subtasks (full tasks in their own right, with their own assignee, dates, and estimate) and lightweight checklists for the quick stuff. Parent progress rolls up from children automatically, so a glance tells you a deliverable is 50% there without opening it.
Link tasks as "blocks" or "waiting on" and the dependency chain becomes a real schedule. Slip the API integration date and every downstream task reschedules itself, so the critical path stays honest instead of going stale in a spreadsheet.
Story points, budget, squad, reviewer, contract number · whatever your process tracks, add it as a typed custom field on the task. Text, Number, Dropdown, Date, Person, Formula, and Currency types render natively on the card and roll up into views and reports.
Status isn't a fixed enum. Define the exact columns each workspace works in · Backlog, In progress, In review, Done, or a 9-stage release pipeline if that's your reality. Priorities run Urgent to Low and drive sort order, filters, and at-a-glance flags.
Assignee, dates, estimate, labels, comments, and attachments live on one task.
Parent tasks show completion straight from their subtasks and checklists.
Blocks and waiting-on links reschedule the whole chain when a date slips.
Seven custom-field types capture exactly what your process tracks.
Custom statuses per workspace mean the board matches how you actually work.
Urgent to Low drives ordering, filters, and the flag on every card.
Open a task and the fields, the description, the subtask checklist, the attachments, and the full activity thread are all right there. No tab-hopping · status, assignee, dates, estimate, labels on the left; the work in the middle; every comment and time log on the right.
Three panes mean nothing about the task is more than a glance away.
The subtask list tracks completion right inside the task you're reading.
Specs, diffs, and screenshots stay on the task, not lost in a chat thread.
Estimate and logged hours sit beside the work, so effort stays honest.
Discussion lives right on the task, with full author history.
Every status change, log, and comment is timestamped on one activity feed.
Link tasks as blocks or waiting-on and the dependency graph becomes a live schedule. The accent chain below is the critical path · the longest run of dependent work that decides the ship date. Slip any date on it and every downstream task moves with it.
The accent chain shows the run of work that decides your ship date.
A blocked task can't start until its blocker closes, and it says so on the card.
Track loose dependencies that inform sequence without hard-stopping work.
Slip an upstream date and every downstream due date moves to match.
Circular dependencies are caught before they create an impossible schedule.
When a blocker closes, the waiting assignee is notified the work is clear.
Add typed fields, define the statuses your team works in, and set priority levels · on the left. The right pane renders a real task card with those exact fields and sample values. What you configure is what your team sees, with no developer in the loop.
Text, Number, Dropdown, Date, Person, Formula, Currency · cover any data.
Compute a value from other fields on the task, recalculated automatically.
Mark a field required and a task can't close until it's filled in.
Define the exact stages each workspace works in, color-coded.
Urgent to Low drive sort order, filters, and the flag on every card.
Build fields and statuses in the console · they render live, no deploy.
Set a task to repeat every day, week, month, or on completion, and the next occurrence spawns the moment this one closes. Save a checklist or a whole task as a reusable template, then drop a pre-built deliverable into any project in one click.
Daily, weekly, monthly, or on-completion · the next task spawns itself.
Recurring chores spawn the next instance the moment this one closes.
Save a reusable checklist and drop it onto any task in one click.
Pre-built deliverables with subtasks, fields, and reviewers, ready to drop in.
Turn any task into a template so good structure never gets rebuilt by hand.
Every recurring or templated task starts identical, so nothing gets missed.
80+ ready-to-run project templates, one for every kind of work your team takes on. Each ships with the right views, task stages, custom fields, automations, and a starter task list already in place. Pick one, point it at your team, and you are planning in minutes, not days. AI Assist can reshape any template to your exact process in one prompt.
Break work into sprints, point the backlog, and watch a live burndown call the finish line. Milestones keep the dates honest · the quarter roadmap keeps the whole org aligned. One planning surface for the people doing the work and the people asking when it ships.
Every sprint is a real record with a name, a goal, a start date and an end date. Drag stories from the backlog into the sprint, point them in your scale, and the commit total adds itself up. A live progress bar shows points done against points committed so standup takes 90 seconds, not 15 minutes.
The burndown plots remaining points against the ideal line so you can see a slipping sprint on day 4, not day 9. Velocity bars roll up the last six sprints so your commit for the next one is grounded in what the team actually delivers, not what they hope to.
Milestones are real dated checkpoints with a name, a due date, and a status that the work itself drives. As tasks close, the progress bar fills and the status chip flips. A milestone that goes red tells you the date is slipping while there's still time to do something about it.
The roadmap view lays your workstreams across the quarters as horizontal bars, with dependency links between the ones that block each other and a "now" marker that moves with the calendar. Share it with stakeholders and the "when does it ship" question answers itself.
Name, goal, dates, and a committed point total · every sprint is a real record, not a sticky note.
Drag stories in, point them, prioritize them · the commit total does its own math.
Ideal vs actual remaining, refreshed daily · a slipping sprint shows itself early.
Status chips driven by the work, not by optimism · late dates raise their hand.
Quarter swimlanes with dependencies and a now marker · one link answers "when."
Whatever the sprint did not finish rolls into the next one with the points intact.
One screen: the sprint you're running on the left, the backlog you're pulling from on the right. Drag a story across to commit it · watch the point total and progress bar update live. Whatever doesn't finish rolls into the next sprint in a single click, with its points and history intact.
Stop tab-hopping · pull from the backlog into the running sprint without losing your place.
Drag a story across or tap the plus · the committed point total recalculates instantly.
Points done against points committed, front and center · standup reads itself.
High, Med, Low flags so the team pulls the right work first, not the loudest.
One click rolls every unfinished story into the next sprint, points intact.
Each sprint names who's driving it, so accountability never lands on "the team."
The burndown plots remaining points against the ideal line, so a sprint that's drifting shows it on day 4. Velocity bars roll up the last six sprints so the next commit is grounded in delivery, not optimism. Carry-over gets its own number, because pretending it's zero never helped anyone.
The dashed ideal line against real remaining points · drift is obvious, not buried.
Commit the next sprint from what the team delivers, not what it wishes it could.
The unfinished number gets its own tile instead of quietly inflating the next commit.
When actual crosses above ideal, the AI agent raises the sprint before standup does.
One donut tells the room how much of the commitment is already in the done column.
Project the burndown to its crossing point and call the real finish date early.
A vertical timeline of every milestone, each with a due date, a status the tasks themselves drive, and a progress bar. On time stays green, slipping goes red, and you find out while there's still time to act. No more discovering a missed date the morning it was due.
New marketing shell and pricing live behind a flag for the design partner cohort.
Migrate every client off the legacy endpoints before the old surface is retired.
Four tasks still open on the customer table import · owner notified, slipping the date.
Public launch once the soft launch is signed off · depends on the soft-launch milestone.
Every dated checkpoint in order · the project's spine in a single scroll.
Chips flip as tasks close · On time, Late, In progress, Upcoming, never hand-set.
A slipped due date turns red and notifies the owner while there's still room to react.
Task count and a fill bar on each one · "82% done, 4 open" instead of a guess.
Milestones from Apollo and Northwind share one timeline so dependencies surface.
Every due date is real · reschedule once and every dependent view follows.
The roadmap view lays each workstream across the year as bars that span the exact quarters they run. Dependency links show what blocks what, and a live "now" marker keeps the picture honest. Share the link and the question "when does it ship" answers itself.
A Q1–Q4 header over swimlane bars · the whole year reads in one frame.
Platform, Mobile, Growth each get a row so nobody's effort hides inside another's.
A dashed line from the bar that blocks to the bar that waits · the order is visible.
A vertical line that tracks the calendar · past, present, and plan in one look.
Send the link to stakeholders · "when does it ship" answers itself, no meeting needed.
Slide a bar to a new quarter and the dependents and now-line redraw with it.
Time lives where the work lives. Log hours against the same tasks your team already runs on the board, start a native timer with one click, flag what's billable and at what rate, and watch capacity fill before anyone burns out. Estimated vs logged sits on every task, so the plan and the reality finally agree.
Every entry captures the minutes worked, the date, and a note, grouped into a familiar Mon-Sun grid. People fill in the week, a manager reviews the totals, and a single Approve locks the sheet for payroll and billing. No spreadsheet round-trips, no copy-paste into a separate tool.
One click starts a timer pinned to the task you're on. Stop it and the elapsed time logs straight to a time entry, with the billable flag and rate carried through. No separate tracking app, no remembering to log it later, no guessing what the morning actually went to.
Flag an entry billable and attach a rate, set per person, per project, or per task. Logged time rolls up into a billable total you can hand to Collect as invoice lines, with the non-billable hours kept separate so internal work never reaches a client. The gap between work done and revenue captured closes itself.
Each person carries a weekly capacity from their profile. Allocated hours stack against it as a bar that turns red the moment someone is over-booked. Availability and PTO knock the ceiling down for the week, and the AI agent suggests exactly which hours to move so no one quietly drowns.
Hours log against the same tasks the board runs on, never a parallel tool.
Start, stop, and the elapsed minutes land on the current task instantly.
Flag and rate per entry, so logged hours roll straight into invoice lines.
Estimated hours sit beside actuals on every task, so overruns surface early.
Capacity bars go red the moment a week is booked past its ceiling.
One click freezes a week for payroll and billing, with a clear status trail.
Tasks down the rows, Mon-Sun across the top, hours in the cells. Totals add up live in both directions, the estimate sits beside the logged total, and a single Approve locks the week for payroll and billing. The grid your team already pictures when they hear the word timesheet.
Tasks as rows, Mon-Sun as columns, hours in the cells, exactly as expected.
Daily totals along the bottom, task totals down the side, all live.
A single Approve locks the week for payroll and billing downstream.
Draft, submitted, or approved, the chip says where every sheet stands.
Estimated hours sit beside actuals so the week's overrun shows immediately.
Approved weeks freeze for the team and stay editable only to managers.
A running clock pinned to the task you're on. Mark it billable, set the rate, hit stop, and the minutes write straight to the task. Today's entries stack up underneath with their billable chips, and a small bar shows estimate vs actual so a task that's running long can't hide.
The clock tracks the task you're on, so nothing logs against thin air.
Flip the toggle and set a rate before the timer even stops.
Elapsed minutes save as a time entry with the date and a note.
Every entry logged today stacks up with its billable chip and duration.
A bar per task turns red the moment logged hours pass the estimate.
Today's billable dollars tally as you log, ready to push to an invoice.
Every person carries a weekly capacity. Allocated hours fill a bar against it, going red the instant someone is over-booked. PTO and availability lower the ceiling, skills tags show who can absorb the overflow, and the AI agent spells out the exact rebalance. Workload becomes a decision, not a surprise.
Each person's weekly capacity sets the ceiling allocation fills against.
The bar flips red the moment booked hours pass the weekly ceiling.
Time off and availability shrink the week's capacity automatically.
Skill tags show who can actually take a task, not just who's free.
The AI agent names the exact hours to move and from whom to whom.
Accept the suggestion and the work shifts across the team in place.
No-code rules move tasks, notify owners, and create follow-ups the second a status changes. Reusable templates spin up a whole project plan in one click. Public intake forms turn requests into routed, assigned tasks. Proofing and approvals close the review loop with pinned comments and a clean sign-off bar · every step writes to the activity log.
Build automations from plain triggers, conditions, and actions. The moment a task changes status, gets assigned, or hits a due date, the rule fires · moving it, notifying people, and spawning follow-up subtasks. Every action lands in the task activity log so nothing happens silently.
Save any project as a template · phases, tasks, subtasks, dependencies, default assignees, and relative due dates all come along. Launch a new engagement and the plan is fully populated before the kickoff call ends. The AI Assist can draft a starter template from a one-line brief when you don't have one yet.
Publish a branded intake form to a link or embed. Every submission becomes a task in the right project, with the right team, priority, and template applied by routing rules. No more inbound work living in email threads · it lands in your task list ready to move.
Drop numbered pins directly on a creative and keep every comment tied to the exact spot it refers to. Versions stack so the team always reviews v3, not last week's export. Reviewers approve or request changes from a routing bar, and each decision is logged to the activity log.
Status moves, notifications, and follow-ups fire automatically the instant a task changes.
Templates populate phases, tasks, and due dates before the kickoff call ends.
Forms turn inbound requests into routed, assigned tasks.
Feedback sticks to the exact spot on the creative, never lost in a thread.
Approvals route to the right reviewers and record who signed and when.
Rules, intake, and approvals all write to the task activity log for a full trail.
A visual when → if → then builder with a library of popular recipes you can flip on with a toggle. Chain conditions, stack actions, and target custom statuses · every fired rule lands in the task activity log so the team always knows what moved a card and why.
Build automations from plain triggers, conditions, and actions with no code.
Flip on proven automations with a toggle, then tweak them to fit.
Combine and / or filters across any field so rules fire only when they should.
Notify, move, assign, tag, and spawn subtasks all from a single rule.
Trigger on and move to your own statuses, not just a fixed set.
Each fired rule writes to the task activity log so nothing moves silently.
A client fills a clean form · a routing rule reads the request type · and a fully assigned task appears in the right project. No inbound work hiding in email. Every submission becomes a task with the team, project, and priority already set.
Publish a request form to a link or embed it on any page.
Each submission becomes a task row, no copy-paste from email.
Map each request type to a team, project, priority, and template.
Briefs and reference files land on the task ready for the assignee.
Requesters get a link to watch their request move without an account.
Required fields and validation keep intake consistent and complete.
Pin feedback directly onto the creative, keep every comment tied to a numbered spot, and stack versions so reviewers always see the latest. An approval routing bar shows who signed and who's still pending · every decision is logged to the task activity log.
Drop numbered pins on the asset so every note points at the exact spot.
Comments stay keyed to their pin, so context never gets lost.
Reviewers always open the current version, with old ones a click away.
Sequential or parallel reviewers, each tracked from pending to approved.
Bounce an asset back with the open pins attached for the next pass.
Every approval is logged to the task activity log.
AI Assist for Manage is trained on every task, sprint, dependency, and hour logged in your workspace. Ask what is blocking the sprint, who is overloaded, which project is slipping, and what the client update should say. The agent reads the whole board and can move the work forward while you are in the standup.
"What is blocking Sprint 14?" AI Assist traces the dependency chain, finds the blockers, reassigns, and flags the risk on the burndown.
"Draft the client update for Apollo." AI Assist compiles milestones, risks, and progress into a RAG status with a recovery plan.
"Anything at risk this week?" AI Assist surfaces overdue and stale tasks, reschedules the chain, and nudges every owner.
"Who has capacity for the QA?" AI Assist reads the workload view, finds the right person, assigns, and protects the sprint goal.
"Break this scope into a plan." AI Assist drafts the tasks, subtasks, dependencies, and a timeline from a one-paragraph brief.
"Why is delivery slipping?" AI Assist reads velocity, cycle time, and workload to pinpoint the bottleneck and propose the fix.
AI Assist reads the day's activity and posts a crisp digest of what moved, what is blocked, and what needs a decision.
"How are we tracking this quarter?" AI Assist renders a board-ready deck of on-time rate, velocity, and utilization in your brand.
DMs, channels, threads, voice, video up to 10, screen share, AI agents in the same thread · the entire communications layer built into the console so your team never has to leave Manage to run the standup or unblock the work.
DMs, channels, threads, voice, video · all in-console.
Screen share, recording, transcripts auto-attached to threads.
Reads the board, attaches files, moves the work forward for you.
Pull a task, its status, and its blockers into the thread without leaving chat.
Blocked tasks and at-risk milestones post to the channel that owns them.
Reassign a task or move it to QA right where the conversation happens.
A request lands and the work runs itself · task created and routed, estimated and sprinted, dependencies linked, board moved, time logged, proofed, approved, and the report updated. 9 nodes, atomic, idempotent, audit-trailed.
"New design request · Apollo Rebrand · homepage hero · priority High."
Routing rule fires · task created in Apollo Rebrand · assigned to the Design team · priority High.
5 points estimated · pulled into Sprint 14 · capacity checked before commit.
Waiting-on the API task · start date auto-set after its finish · Gantt updated.
To do → In progress when the owner starts · status syncs to every view at once.
Blocker detected · owner notified · the whole dependency chain auto-shifts so the deadline holds.
Hours logged against the task · estimate vs actual updated · the person's workload recalculated.
Asset sent for review · annotations resolved · approval routed and signed off in sequence.
Task closed · milestone progress ticks up · the dashboard and client status report update themselves.
Create, route, estimate, schedule, move, log, proof, report · all fire from one intake.
Every step keyed by task ID. Re-runs never duplicate work or double-log time.
Each node writes its before and after to the task activity log.
Simulate the whole flow against a test task and watch every node fire safely.
A blocker reschedules the dependency chain instead of blowing the deadline.
Start a flow on a request, a status change, a due date, or a deal won in your CRM.
Most tools sell the views, the time tracking, the proofing, and the reporting as separate SKUs, and none of it talks to your CRM, billing, or websites. Manage ships them as one console inside the whole platform. Hover any card to compare.
Free for life for one user. Bring your whole stack into one place — no credit card, no time limit.