Dependency Tracking (+ Gantt chart)

Hi Guys,

This, of course, is a huge, broad subject. But I wanted to get the conversation started as you guys actually have asked for feedback if there’s interest in the feature yourselves!:

This is from one of your new tutorials here: . | Fibery

So to kick things off, I’d love to see a lot of what you had in TargetProcess, like:

  • Due Date extension that would include both an “original” due date, and “actual” completion date
  • Dependent tasks that would wait on Predecessor, and seeing this in the Gantt. In TP as I recall these were color-coded differently and you had even nice “shades” to help differentiate various states of the related items in the Timeline/Gantt view:

  • Concept of Lead/Lag time that helps plan in dependencies.

Timeline is already a useful view, so hopefully these will be things that will start to come as you guys evolve. I posted some suggestions around Timeline and Gantt-style improvements, but nobody responded. Here it is for reference:

Would love to see some of this stuff soon as they are another typical feature of all the “big” Project Management apps that I think a lot of users coming from those tools (like me!) will be expecting.


Hi Guys,

I have an increasing need for some dependency handling in Fibery, and I wanted to suggest an Extension for this. Here are a few of the elements of this request:

  • My team has a lot of intra-Type dependencies. For example, a whole project can be depending on one task getting done. A “general” task can rely on a “dev” task, that are tracked in different Types. So ideally it would be great if you could simply make any entity dependent on “any” other - with say the requirement that they both need a State, but otherwise they can be in different Types

  • This would be great to have visible visually. In Timeline, if you had separate Types with Entities dependent on one another, perhaps a dependency tracking line would only show up if you show both Entities in the timeline. Some illustrations of this type of Gantt visibility of dependencies is shown in this post:

  • The extension would include some triggers, such as moving an entire set of dependent entities if the dates are changed on predecessors, etc. The use of “Lead Time” and “Lag Time” would be great here.

Thanks for the consideration of this!


I hadn’t seen this request before, but I do think this is quite interesting and inspired! I thought it is worth bringing it up on the board so others can also have a quick look.

I am not sure if dependencies are at all on the roadmap but they are a must for any serious project management work. In almost all cases though, the way their are setup is quite rigid and does not take into account that decencies and constraints can exists across different projects and different types of activities/types. I agree that an extension seems to be the best way of doing this across the entire workspace and would really be powerful (similar to way references extension works). I think automation may be another way but this seems more radical/inspired to me!

I was sure where to register my vote (here or on this topic), but seemed more interesting so you got my vote!


Could this be achieved if we had fields for all types, polymorphic relations, combined with automations?


Upvote!. In the real estate project development field of our company, dependency visualization is also a necessity. Hiring many subcontractors is interdependent. If a subcontractor’s work is delayed, it affects the start date for many other subcontractors’ work.


Great thank you @cannibalflea for the support! Glad there is another out there who could use this, I hope the Fibery team moves it forward soon and we can gain votes as well!

And to your comment @Chr1sG:

I think you’re right, but as with a lot of mash-up solutions around here that involve ways to manipulate Fibery to do things that are simple “available” in other apps, I’m not sure 100% off hand that what you propose would cover the need here. Another example is a simple “+” to add an entity from a Template I talked about here, where Michael is proposing a solution that I think will work, but I haven’t had the time to analyze it.

So in this case, something like an extension for dependencies, or something that is obvious to the user that it’s a way to “create dependencies,” when in reality it could be just a wrapper of just what you describe - Polymorphic +Fields of all Types (good idea there but unfortunately I’m out of votes to vote for it). Does this make sense? In other words, it would be great to get some underlying features in Fibery released, but then still have some additional UI/UX stuff so it’s easier to achieve the functionality more intuitively.

And thanks again for bringing up Polymorphic. I see you used one of your valuable votes for that one as well :slight_smile:

I’ve created a template app which shows some basic Gantt chart/dependency functionality:

Hope some of you might find it useful :slight_smile:

As it is, it’s currently limited to only one type of entity (Task) so doesn’t really solve the complete problem of having entities of different types depending on each other, but I reckon it could be expanded fairly easily.

Not bad. Nice workaround.
I think ClickUp has a pretty solid implementation for task dependencies, including:

  • Add one or multiple tasks that this task is WAITING ON
  • Add one or multiple tasks that this task is BLOCKING
  • Add one or multiple tasks that this task LINKS TO

1 Like

That’s interesting.
It would seem that ‘Waiting on’ = predecessors and ‘Blocking’ = successors, so how do the dependencies in ClickUp get reflected in project scheduling?
Like, if the person responsible for ‘2.14 Release’ decides that they are running late, what happens?

I’m not sure, but here’s a more detailed description of ClickUp’s implementation: Task Dependencies | ClickUp Tutorials & Docs

In target process and many other tools, one can link an entity(story, task, feature etc) to any other entity and mark that link as a blocker, dependency, relation or link).
In Fibery one cannot do this currently in a generic way. One has to be explicit and define a type of entity as a blocker or relation. This is a bit limiting and verbose.
It would be good to create a link to any item in fibery and mark it as a blocker, dependency of, target of.

I see that the discussion so far has been very linked to Gantt Charts (at list with regard to visualizing dependencies). So I would like to add another perspective on how to visualize dependencies.

As Gantt Charts display how entities are schedules, they are useful only for, well, entities that are scheduled. Displaying dependencies between the entities in the Gantt Chart is important, as it it useful to know how rescheduling one entity may affect other entities dependent on it.

However, I truely believe that it should not be the primary way to visualize dependencies. And I highly object to the notion that Dependency Visualization == Gantt Charts (which, to be fair, was never explicitely expressed here, yet the fact that Gantt Charts were the only visualization method suggested may leave an implicit impression that Gantt Charts indeed eqaul Dependency Visualization).

The main problem is that Gantt Charts cannot (by design) display all entities, only scheduled ones.
Yet dependencies are not limited to scheduled entities only. Any two entities (as long as both can be completed) can have a depencency relation between them. How will the depedencies of such entities be visualized, if Gantt Charts == Dependency Visualization?

I suggest that in addition to Gantt Charts, another way to visualize dependencies should be provided.

Such a method will need to take into concideration the following properties of dependencies:

  • An entity can be dependent on more than one entity
  • Multiple Entities may be dependent on one entity
  • Entities of different types may be dependent on one another (for example, a task may be dependent on an entire project or even multiple projects being completed, or on a project and multiple tasks).
  • It should be possible to accomplish any goal represented by an entity- that is, no “dependency circles” allowed (an entity cannot be dependent on another entity who is in turn dependent on the completion of the first entity).

Looking at the properties of dependencies mentioned above, it seens to me that a good way to represent dependencies is a graph, where the nodes are the entities. However, not any graph will suffice- the graph should be directed (which represents the direction of dependencies) and should not allow any circles.

In my opinion, a good way to represent such a graph is as followed:

(1) All entities that are not dependent on any other entity should be placed on the left.

(2) All entities that are dependent on any other entity should be placed to the right of that entity with a line connecting them.

(3) Many Entities which are dependent on a single entity or on the same group of entities can be grouped together and surrounded by a thin rectangle. A line will be drawn from the common entities to that rectangle to simplify the view (for example, if ten entities are dependent on the same 3 entities, if a single line is drawn from every entity on which the 10 etities are dependent on to each one of the 10 entities, there will be 30 lines. With the “simplification” there will only be 3 lines).

(4) This kind of grouping can also be done for entities that have the same group of dependent entities.

(5) I think that this kind of grouping can be preserved even if some entity within the group have dependencies that they do not share with the rest of the group. In such a case, a line will be drawn directly between the entities (exacly like in (1)) “passing” the line of the rectrangle. As long as the View does not look “too messy” I think this should be fine. However, I cannot provide a full definition of what “too messy” means, as it is quite complicated.

I add here a demonstration of how such a view may look like. A appologize for the poor quality.

Many apps (including clickup, which was mentioned in the discession above) treat depependency visualization as “Dependency Visualization == Gantt Chart”. As far as I know, no app has implemented any view visualizing dependencies that it not a Gantt Chart. I truely believe that this kind of feature will not only provide Fibery with a competitive adventage over other apps, but that it is also vital for fully visualizing dependencies.
I would be exhilarated to see a discussion regarding other ways to visualize dependencies other than a Gantt Chart.

Hope that what I wrote added something useful to the discussion :grin:


There is actually one its called TaskHeat
Wonderful implementation!


Notion just came out with a very nice looking implementation of this:


A gantt chart is my biggest want right now. In my opinion, the current timeline view is completely insufficient for anything beyond a simple overview. Basic timelines have their place, but CPM scheduling, via a gantt chart visual, is the standard (and usually a client requirement) for most industries that manage sufficiently complicated projects.

:star::star: :star: Instead of modifying the timeline view, my vote would be to use the new Table 2.0 view (list grid prototype) as a foundation for an alternative scheduling view (as an optional collapsible right panel on the table view itself) that shows a more traditional Gantt structure

  • Timeline Issue #1: Information isn’t consistently shown
    • :shrimp: An item’s information is restricted to only being on it’s timeline bar. This is difficult to read because first you have to hunt around the screen to find your entity, then discover that some of that information is very likely truncated because it is longer than the bar, which causes you to never be happy with the zoom level.
    • :muscle: Timeline’s are fine for basic summaries. But visualizing the schedule of a complex project with lots of moving parts would benefit immensely with a familiar table layout to view/edit your information. Then the schedule bars can just show colors/shapes/symbols/etc.
  • Timeline Issue #2: Information isn’t consistently structured
    • :shrimp: The only hierarchical structure is through lanes. Without lanes, there is no way to create a consistent flow and visualize a critical path. Fibery sorts timeline items by slot availability, meaning regardless of user sorting rules if it can fit at the top it will.
    • :muscle: Lanes could maybe be usable, but there is a cap limiting only 100 lanes. Additionally, if you show lane fields to be able to edit in the timeline, lanes just take up too much space to see the big picture. Tables solve both of these problems.

As an example, already uses this exact type of collapsible right gantt view panel (as long as you have a date range). I think this is a very smart way of implementing it. You can close the gantt sidebar and focus on column editing or open it up to see the visual schedule representation.

I feel like dependency tracking wouldn’t be needed in the first release, but would be a huge upgrade and easily possible once the relationship properties feature is released, which would then allow dependency types: (start-to-start, finish-to-start, etc.)

Scheduling is critical in so many industries. And the possibility to house that schedule within Fibery allows enormous potential for customers to link their schedule with all of their other information :rocket::rocket:

Side note for anyone interested. This is a fascinating post from the Edward Tufte forum on scheduling graphics



Just came back here to this thread because I’m also one of the people who is urging to have a gantt chart on Fibery.

@mdubakov Is it somehow in the horizon for next year maybe?


So far we have plans to re-work TImeline View completely next year indeed. But it is very hard to provide any sane estimate right now.