Kaneo: From a Thesis in Skopje to an Open-Source Project Management Platform
What started as a bachelor’s thesis in Skopje has grown into an open-source project management platform with contributors from around the world. Created by software engineer Andrej Acevski, Kaneo aims to give small teams the tools they need to organise their work without a maze of configuration.
We spoke with Andrej about building in public, the engineering decisions behind Kaneo, and how local communities like Base42 can help more people take their first steps in open source.
“I wanted the middle: create a workspace, create a project, start working. Everything past that should be opt-in.”
From a thesis in Skopje to an open-source platform
What is Kaneo, and how did it start?
I'm Andrej Acevski, a software engineer from Skopje and the creator of Kaneo.
Kaneo is an open-source, MIT-licensed project management platform: everything a small team needs to organise work (projects, boards, lists, calendar and Gantt views, labels, custom fields, recurring tasks, time tracking, notifications, search) without the configuration maze enterprise tools put in front of you. You can self-host it with a single Docker image or use the managed version at cloud.kaneo.app.
It started in December 2024 as my bachelor's thesis. I didn't want to build something that would die the day I defended it, so I built it in public from the first commit. v1.0 shipped in June 2025, and today we're at v2.48 with more than 130 contributors, over four thousand commits, and close to ten thousand GitHub stars.
Why build your own project management tool?
Every tool I tried was either a glorified to-do list that fell apart once two people used it, or an enterprise platform where you spend a week configuring workflows and permission schemes before creating a single task.
I wanted the middle: create a workspace, create a project, start working. Everything past that should be opt-in.
Data ownership was the other trigger. A project management tool holds your roadmap and internal discussions, and many technical teams don't want to hand that to a third party. Self-hosting had to be first-class, not an afterthought.
Who is Kaneo built for?
Developers and technically minded small teams: startups, agencies, open-source maintainers, and the self-hosting and homelab crowd.
Today it's used by individuals, small product companies, and teams who picked it specifically because it runs on their own infrastructure. We have a Helm chart because people asked for Kubernetes, and a full admin area because companies running Kaneo for everyone asked for proper tools to manage it. Different users, same wish: a tool they understand in five minutes that stays out of the way.
Inside Kaneo: architecture and engineering
What is the tech stack behind Kaneo?
Everything is TypeScript in a pnpm monorepo.
The frontend is React 19 with Vite, TanStack Router and TanStack Query, Tailwind CSS v4, Zustand, Tiptap for the editor, and dnd-kit for drag and drop. It's translated into 22 languages, Macedonian included.
The backend is Node.js with Hono. Schemas are written in Zod, so validation and the OpenAPI docs come from the same definition. PostgreSQL with Drizzle ORM stores the data, and Better Auth handles passwords, email codes, social login, OIDC, and API keys. Real-time updates go over WebSockets, with Redis Pub/Sub when you run multiple instances. Attachments go to S3-compatible storage through presigned URLs.
Around that sit a mobile app for iOS and Android built with Expo, a command-line client, an MCP server so AI tools like Claude can work with your boards, importers from other tools, and integrations with GitHub, GitLab, Gitea, Slack, Discord, Telegram, and Mattermost.
Two honest course corrections: we started on Bun and moved to Node.js, because for a self-hosted product the boring, battle-tested runtime wins. And we started on SQLite and moved to PostgreSQL before v1.0, once real multi-user workloads made the tradeoffs clear.
For deployment there's a single Docker image, Docker Compose, a Helm chart, and a setup CLI called drim that gives you a running instance with HTTPS in one command.
How do you avoid over-engineering?
By solving the problem that exists now, and being willing to walk things back.
Early in 2025 we ripped WebSockets out and replaced them with polling, because the real-time code wasn't paying for its complexity. A year later, when collaborative editing genuinely needed it, we brought them back properly. Both calls were right; keeping half-working infrastructure "because we'll need it eventually" would have been the mistake.
The codebase scales through boundaries, not abstractions. Each feature lives in its own module, files stay small with one responsibility each, and tests sit next to the code. A new contributor can find where something lives without a tour guide, and that's what scalability means to me: the code stays easy to change.
What are the main security challenges?
Access control above everything. Being logged in isn't enough; every query is scoped to the workspaces and projects the user can actually see, enforced in the API, not the UI. Admins can define custom roles and limit members to specific projects.
I deliberately didn't roll my own authentication. Better Auth handles sessions, OAuth, and API keys, and every API input is schema-validated.
Self-hosting adds risk SaaS doesn't have: you don't control the environment. So the docs cover HTTPS, reverse proxies, and secrets, upgrades are designed to be boring, and admin actions land in an audit log. In CI, every change is scanned for leaked secrets.
Running the cloud version taught us about abuse prevention, rate limiting, and signup verification. Attackers find a hosted signup form very quickly.
How do you test Kaneo?
Layered. The API has unit tests and an integration suite that runs against a real PostgreSQL database, concentrated where bugs hurt most: permissions, authentication, and data crossing workspace boundaries. The frontend has component tests focused on user behaviour.
We also have end-to-end tests in Playwright that build the real Docker image and walk through actual journeys in a browser, including checking that a second user sees edits arrive live. They run on BrowserStack too, across browsers.
Around that: strict TypeScript, database constraints, linting on every commit, and a check that the published API docs match the code. The honest gap is breadth: the browser tests cover core paths, not every screen, and the mobile app still leans on manual testing.
Building with users
How does user feedback shape the product?
Mostly through feedback.kaneo.app, a feedback board we built ourselves, where anyone can post a request, vote, and follow it until it's released. GitHub issues and community channels fill in the rest.
The rule I follow: respond to the problem, not the proposed solution. Users know exactly what hurts; designing the fix is my job. Two different requests often share one underlying problem.
Repetition is the strongest signal. One request is a data point; five independent reports is a roadmap item. The PostgreSQL migration, real-time collaboration, and the admin area all came from users hitting real limits. At the same time, an open-source project dies by a thousand accepted feature requests, so "no, but here's why" is a sentence I've had to get comfortable saying.
What’s next for Kaneo?
The roadmap is on feedback.kaneo.app, ranked by votes. In progress right now: showing and hiding subtasks in every view, and a workspace-wide task list and board with a quick assignee filter. Right behind them: task relations across projects, saved views with advanced filtering and grouping, a Forgejo integration, and storing attachments on local disk so small instances don't need S3.
Personally, I'm most excited about getting the mobile app into the App Store and Google Play. It's built and in testing, and mobile is where Kaneo is weakest today.
And the permanent, unglamorous work: making self-hosting easier, so installs, upgrades, and backups don't need a dedicated infrastructure person.
Open source, local communities, and getting started
Does the region need more local open-source projects?
Definitely.
The region is full of strong engineers, and working with international clients has helped build deep technical expertise. More local open-source projects would give that expertise another outlet: a public, lasting record of the products we build, the decisions behind them, and the care it takes to maintain them over time.
It’s also an opportunity to broaden how people see the Balkans: a region known both for engineering talent and for products used around the world. Kaneo started as a thesis in Skopje and now has contributors from all over the world. More stories like that can inspire others to build and share their own ideas.
How can hackerspaces and the community help?
The hardest part of open source isn't technical: the first contribution is scary, and much less so next to someone who has done it before. Places like Base42 can run contribution days and code review sessions and turn "I could never contribute" into "I did, last Tuesday."
Communities also know that open source needs more than programmers: designers, writers, translators, testers, and people who welcome newcomers.
For Kaneo, the most useful help right now: self-host it and tell me where the docs failed you, report bugs with clear reproduction steps, improve translations, review accessibility, and vote on and post ideas at feedback.kaneo.app. Honestly, just using it and giving blunt feedback is enormous.
What advice would you give first-time contributors?
Start smaller than you think. Fixing docs, improving an error message, adding a reproduction to a bug report: these teach you the workflow without the pressure. Many of Kaneo's contributors started exactly like that.
Pick a project you actually use; caring about the problem is what keeps you going.
Read merged pull requests before writing code. They show what maintainers accept better than any contributing guide. For anything bigger than a small fix, open an issue first.
Don't take review personally. It's the project talking to your code, not a judgement of you.
And don't wait until you feel ready. I started Kaneo as a student. The feeling arrives after you start, not before.
What is your favourite open-source project besides Kaneo?
Chakra UI. I've contributed to it, so I saw both the code and the community machinery around it.
It taught me that code is maybe a third of maintaining a serious project. Docs, triage, releases, backwards compatibility, and helping people land their first pull request are the rest, and they're what make people trust a project enough to build on it.
Explore Kaneo and get involved
Try Kaneo Cloud, or visit the Kaneo feedback board to share ideas, vote on requests, and follow the roadmap.