Back

Engineering

Why We Switched From GitHub Issues to Jira to ClickUp

Over the past 15 months, we used and tested three product development tools: GitHub Issues, Jira, and ClickUp. It’s not common for a small startup to switch between so many tools in such a  short time. However, we work with weekly minors (10 minors in a major), so we need a well oiled machine to help with the frequent deployment to production, QA and release notes.

The software management system is essential for understanding what will make it into the version and what needs to be pushed to later. We came to some very interesting conclusions about collaboration abilities and resource management. Here’s what we found.

Project Management Software Requirements

Our requirements were simple and clear. We needed a system for:

  1. Managing major product versions and the minor ones.
  2. Easily organizing information by topics, e.g a list of features and bugs for release notes.
  3. Flexible management of our projects according to hierarchy and timeline, and being able to see who is assigned to which task alongside the task’s status.
  4. Cross-department collaboration and communication: engineering, product, and occasionally marketing.
  5. In addition, we preferred a system that had a clear and clean UI, without displaying too many features - admittedly, not a fan of Kanbans.

Attempt #1: GitHub Issues

We started out with GitHub Issues because I worked with them in the past. To start out with GitHub Issues, the best approach would be  to create milestones, which are high-level topics. Inside milestones, you can create issues and add labels, and assignees. Teams can manage and track these ‘issues’ in a collaborative manner.

We used milestones to track our major versions. The main challenge we had was managing our minor versions. The milestones only have one hierarchy, and we needed sub-hierarchies for our minor versions.

We tried using labels, GitHub Projects, and manipulating the milestones. However, it was too complicated to manage and filter the information we needed. I also needed to create release notes, but it was very difficult to screen the relevant information from the ‘issues’ to create them.

So after six months, when our dev team grew, we moved on.

GitHub Issues Pros:

  • Easy onboarding
  • Clear integration to GitHub PRs - it is very easy to link issues to PRs using the # syntax
  • Intuitive UI
  • Developer-friendly

GitHub Issues Cons:

  • No project hierarchy
  • Filtering information is complicated
  • No option to recurring lists of tasks like QA or version deployment

Attempt #2: Jira

After Issues, we moved on to Jira - a very popular tool among larger engineering teams. Jira can be configured to work in Sprints, which is convenient for certain use cases. Jira was also a somewhat comfortable tool to use.

However, Jira was missing some abilities we needed and the UI is not very modern. We also found the load timing to be slow. Basic actions like filtering and deleting became bulky and non-intuitive. Above all, it was difficult for us to create the hierarchy levels we needed. Especially because of the Sprints mechanism: we wanted to create long-term milestones, not just plan for the next 1-2 weeks.

We found ourselves getting managed by the tool, not the other way around. We spent a lot of time transferring tasks between sprints instead of completing the tasks and simple tasks like deleting multiple issues became a hassle. Creating release notes was also difficult. So after three months of using Jira, we moved on, yet again.

Jira Pros:

  • Comfortable to use (most of the time)
  • Sprint task management
  • Well known by developers
  • Huge amount of customizations

Jira Cons:

  • Difficult onboarding
  • Sprints not milestones
  • Slow loading time
  • Non-intuitive UI (not reactive… a lot of screens required refresh)
  • Huge amount of customizations :)

#3rd Time’s the Charm: ClickUp

Our CTO heard of ClickUp from fellow CTOs. Finally - it had everything we needed.

ClickUp is based on “Spaces”. Each “Space” contains folders, and each folder contains lists. This was the hierarchy we were looking for: simple and straightforward.

ClickUp answered all our requirements:

Requirements #1, #2: Managing Major and Minor Product Versions

We divided the spaces among our departments: engineering, product, and marketing. The “Engineering” space is divided into folders. Each folder is a major or minor version, simplifying our management process.

Requirement #3: Organizing Information According to Topics

We created three recurring lists in each version folder: Bugs & Features, R&D Internal, and Product. Each list comprises the required tasks for the version. Now, when I need to create a list of release notes, I can just use the Bugs & Features list. I make sure it doesn’t have internal information which does not affect the clients, and turn the list into notes.

Recently we also added the “release day” list which holds the QA flows and regression tests we make sure we run before every release.

Requirement #4: Flexible Management According to Hierarchy and Milestones

Folders enable differentiating between the versions, without having to stay at one level. In addition, ClickUp templates enable us to duplicate new version folders with the lists we need. So each time we create a new version folder, we get it pre-made with Bugs & Features, R&D Internal, and Product lists.

Requirement #5: Cross-department Collaboration and Communication

ClickUp enables all of our departments to work together.  For example, product lists are used by Engineering and Product to gain visibility into the mockups that are being developed and the mocks being prepared by Product for the next sprint. Also, when we developed a new commercial website, marketing, product and engineering easily collaborated on the same folders, tasks, and lists.

Additional Features We Like

  • Automations: we use automations to a certain extent. For example, if a developer creates a PR it is automatically placed in the “Review” list. When the task is completed and the PR is merged, it’s also completed in ClickUp.
  • Smart and flexible filtering: This is the main appeal of ClickUp for us. The ability to mark a group of tasks and transfer them to another folder or delete them is a huge time saver. This is relevant, for example, when we need to transfer entire lists of tasks between folder versions. In ClickUp, filtering can be applied to folders or by lists.
    Keyboard shortcuts are well implemented and are a blessing for the developers who like to keep their hands off the mouse.
  • Integrations: We integrate with GitHub, to automatically create and transfer tickets.
    In addition, Figma and slack integrations are available.

ClickUp pros:

  • Scalability: enables agile management of any number of developers and team members, products, and features
  • Flexible and structured version planning: through milestones and by hierarchy
  • Visibility: into the state of development of each version, enabling future planning of sprints
  • Easy to organize and manage
  • User friendly

ClickUp cons:

  • ClickUp are adding more and more features that clutter the UI and slow the loading time

Wrapping it Up: Find a Tool that Scales with You

There are many task and project management tools out there: Trello, Asana, Confluence,

ClickUp, Jira, GitHub Issues, and more. While the features are similar, different solutions operate differently, putting an emphasis on different development needs. Don’t compromise on the right task management product. Map out your needs and try out different tools. Most of them have a free version, which makes it easier.  We’ve been using ClickUp for six months and we couldn’t be happier.


What’s your favorite productivity management tool? Drop us a line on Linkedin and let us know!