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: Dependency management | Fibery Help Center

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 @anayericov 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: