Here at Swimm over 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 devtools 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.

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

Here’s what we found.

Project management software requirements

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

  1. Managing major product versions and minor ones.
  2. Efficiently organize information by topics, e.g. list of features and bugs for release notes.
  3. Flexible management of our projects according to hierarchy and timeline, and seeing 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 with GitHub Issues because I worked with them in the past. To start 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’ collaboratively.

The main challenge we had was managing our minor versions. We used milestones to track our major 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 top-rated devtool 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 includes lists. This was the hierarchy we were looking for: simple and straightforward.

ClickUp screenshot

ClickUp answered all our requirements:

Requirements #1, #2: managing major and minor product versions

We divided the spaces among our engineering, product, and marketing departments. 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 checklists 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 turns the list into notes.

We recently 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 allow 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 teams to gain visibility into (1) the mockups that are being developed and (2) the mockups being prepared by Product for the next sprint.

Also, when we created 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. In ClickUp, filtering can be applied to folders or by lists. 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 move entire lists of tasks between folder versions.
    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 is 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, emphasizing 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 more accessible.  We’ve been using ClickUp for a long time at this point, and we couldn’t be happier.

Learn more about Swimm and sign up for a 1:1 demo.