How the Idea for AB-TASK Was Born
I originally started developing project management software because I couldn't find a proper tool for ERP-LAB (my own small software company with a team of 5-6 people).
It's a pretty typical story: I had a problem, and I decided to solve it by writing the first version of AB-TASK.
We only needed a few things:
A single tool for communication (for both clients and developers)
Time tracking tied to tasks
Report generation for clients
I was young and full of energy, so instead of struggling with integrating several clunky tools, I figured it would be easier to build my own. And I did. Just a few months later, we were successfully using our own task tracker with all the functionality we needed.
That’s how my passion for project management software started.
Of course, by today’s standards, the first version was pretty crude. The backend was pure PHP (no frameworks, an in-house MVC), the frontend was on jQuery, and real-time functionality was handled via WebSockets (also a custom implementation). It worked, but it wasn’t a strong foundation for future growth.
I temporarily switched to full-time employment and started working on the next version of AB-TASK, this time using React, Apollo Client, and a GraphQL API. After five years, the new AB-TASK finally started to feel complete.
The Bigger Picture
Over time, I realized that team collaboration isn't just about tasks and client tickets. At the very least, you also need chats and documentation.
Using multiple separate tools for this is a nightmare.
The problem is fragmentation. Context gets lost, every tool has its own interface, subscriptions pile up. Integrations between systems lead to duplicate information and often make things worse rather than better.
But team communication is essentially a shared information space where work happens. It shouldn’t be scattered across three or four different apps—it should be in one place.
Why Is This So Hard to Solve?
Creating a simple app that covers all team communication is an extremely difficult task. Team communication is messy, chaotic- you need to see the system behind it.
There are literally thousands of tools on the market. But they either solve only part of the problem or end up as bloated monsters with multiple disconnected interfaces crammed under one roof.
Take Jira - it’s strictly for task management (and it’s already a monster many dream of escaping from). Slack is just for chats. Recently, they’ve been trying to become an all-in-one tool by adding tasks and documentation, but again - it’s really just multiple separate tools packed into one.
Despite the oversaturated market, there’s still no real solution. And the demand for better collaboration tools keeps growing.
For example, Linear quickly became the go-to choice for startups. But they didn’t solve the context fragmentation problem either - it’s still just task management plus a ton of integrations. They simply made task management cleaner and better than Jira.
What Makes AB-TASK Different?
A chat, a task, a support ticket, a document... At their core, these are all information channels between team members.
We created a universal communication channel where you can:
✅ Chat in real-time
✅ Work with large content blocks
✅ Edit content together
All in one place, fully real-time. Messages stream instantly. It’s almost like a reinvention of Google Wave (though I only learned about Wave much later).
Each channel has the same interface, but different attributes.
For example:
✅ Tasks have statuses and assignees
✅ Chats only have a title
💡 But to discuss a task, you don’t need to switch to another app - comments inside a task are also a chat! And the task description? It’s a document!
All channels form an endless nested communication graph - a structured information space where context is never lost.
You don’t just see the current conversation or task - you see its entire history:
✅ Where it started
✅ What was discussed earlier
✅ What aspects are covered in documentation and so on.
This is the missing piece that modern teams desperately need. A way to consolidate context instead of constantly losing it.
