What Are Kaneo's Core Features? A Technical Deep Dive into the Open-Source Kanban Platform

Kaneo's core features include workspace-scoped project management, task and label management, real-time WebSocket collaboration, integrated billing with seat management, Better Auth-based authentication with SSO support, third-party integrations (GitHub, Discord), and comprehensive activity logging—all implemented as a modular pnpm monorepo with a TypeScript API and React frontend.

Kaneo is a self-hosted, open-source kanban-style project management platform designed for teams who need full control over their data. Built as a pnpm monorepo, it separates concerns cleanly between the backend API (apps/api) and the frontend web client (apps/web). This article examines Kaneo's core features by analyzing the actual source code implementation in the usekaneo/kaneo repository.

Workspace-Based Multi-Tenancy

Kaneo organizes all data around workspaces as the top-level isolation boundary. Every API request is scoped to a workspace, enabling true multi-tenant deployments where teams operate in complete separation.

The workspace module in apps/api/src/workspace/index.ts handles:

• Workspace CRUD operations
• Member invitation and role management
• Settings and configuration persistence

This design pattern ensures that projects, tasks, labels, and billing data never leak across workspace boundaries.

Project and Task Management

At the heart of Kaneo lies a hierarchical data model: workspaces contain projects, projects contain tasks. The implementation supports:

• Task fields: title, description, attachments, timestamps (created/updated), and ordering
• Project organization: ordered collections with customizable views
• Activity tracking: automatic logging of all mutations via the activity system

The frontend consumes these features through a consistent fetcher pattern. Here's how task creation works:

// apps/web/src/fetchers/task/create-task.ts
import { post } from "@/utils/http";

export async function createTask(workspaceId: string, projectId: string, title: string) {
  return post(`/api/workspaces/${workspaceId}/projects/${projectId}/tasks`, { title });
}

// apps/web/src/hooks/mutations/use-create-task.ts
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { createTask } from "@/fetchers/task/create-task";

export function useCreateTask(workspaceId: string, projectId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (title: string) => createTask(workspaceId, projectId, title),
    onSuccess: () => qc.invalidateQueries(["tasks", workspaceId, projectId]),
  });
}

Label System with Assignment

Kaneo implements first-class labels as standalone resources rather than simple string tags. This enables:

• Color-coded visual organization
• Reusable label definitions across projects
• Filtered views by label assignment

The label module in apps/api/src/label/index.ts exposes full CRUD plus assignment operations:

// apps/web/src/fetchers/label/assign-label.ts
import { post } from "@/utils/http";

export async function assignLabel(workspaceId: string, taskId: string, labelId: string) {
  return post(`/api/workspaces/${workspaceId}/tasks/${taskId}/labels/${labelId}`);
}

// apps/web/src/hooks/mutations/use-assign-label.ts
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { assignLabel } from "@/fetchers/label/assign-label";

export function useAssignLabel(workspaceId: string, taskId: string) {
  const qc = useQueryClient();
  return useMutation({
    mutationFn: (labelId: string) => assignLabel(workspaceId, taskId, labelId),
    onSuccess: () => qc.invalidateQueries(["task", workspaceId, taskId]),
  });
}

Real-Time WebSocket Collaboration

Kaneo delivers live updates across connected clients through a WebSocket broadcasting system implemented in apps/api/src/ws/index.ts. The architecture supports:

• In-memory adapter: for single-instance deployments
• Redis adapter: for horizontal scaling across multiple API nodes

Events propagate workspace-scoped changes instantly, enabling collaborative editing without page refreshes:

// apps/web/src/hooks/use-realtime.ts
import { useEffect } from "react";
import { useBroadcast } from "@/utils/broadcast";

export function useRealtimeUpdates(workspaceId: string) {
  const broadcast = useBroadcast();

  useEffect(() => {
    const handler = (msg: any) => {
      // Handle { type: "task-updated", payload: {...} }
    };
    broadcast.subscribe(`workspace-${workspaceId}`, handler);
    return () => broadcast.unsubscribe(`workspace-${workspaceId}`, handler);
  }, [workspaceId, broadcast]);
}

Integrated Billing and Seat Management

Unlike many open-source alternatives, Kaneo includes production-ready billing infrastructure in apps/api/src/billing/index.ts. This module provides:

• Entitlement checking: verify feature access before execution
• Seat synchronization: manage paid user slots
• Checkout creation: integrate with payment providers

Frontend components query entitlements to gate UI elements:

// apps/web/src/fetchers/billing/get-entitlement.ts
import { get } from "@/utils/http";

export async function getEntitlement(workspaceId: string) {
  return get(`/api/workspaces/${workspaceId}/billing/entitlement`);
}

// apps/web/src/hooks/queries/use-entitlement.ts
import { useQuery } from "@tanstack/react-query";
import { getEntitlement } from "@/fetchers/billing/get-entitlement";

export function useEntitlement(workspaceId: string) {
  return useQuery({
    queryKey: ["entitlement", workspaceId],
    queryFn: () => getEntitlement(workspaceId),
  });
}

Authentication and Single Sign-On

Kaneo leverages Better Auth for session management, configured in apps/api/auth-schema.ts. The system supports:

• JWT-based stateless sessions
• GitHub OAuth
• Google OAuth
• Discord OAuth
• Custom OAuth/OIDC providers

This flexibility allows organizations to integrate with existing identity infrastructure without maintaining separate user databases.

Third-Party Integrations

Kaneo extends its capabilities through dedicated integration modules:

Integration	Source File	Purpose
Discord	apps/api/src/discord-integration/index.ts	Bot communication and notifications
GitHub	(within integrations)	App installation verification and repository linking

These integrations follow the same workspace-scoped pattern as core features, ensuring proper isolation and permission checks.

Activity Logging and Audit Trail

Every mutating operation in Kaneo generates an activity event processed by apps/api/src/activity/index.ts. This enables:

• Real-time activity streams in the UI
• Audit trails for compliance
• External consumption via webhooks or event subscriptions

The activity system integrates with the WebSocket layer to push updates immediately to connected clients.

Internationalization Support

Kaneo prepares for global deployment through centralized string management in i18n/resources.ts. While the current implementation focuses on English, the architecture supports:

• Multiple language packs
• Runtime language switching
• Type-safe key references

Summary

Kaneo's core features demonstrate a mature, production-oriented architecture:

• Workspace isolation provides multi-tenant security at the data layer
• Modular monorepo structure enables focused development and testing
• Consistent fetcher-to-hook pattern delivers type-safe frontend consumption
• Real-time infrastructure supports collaborative editing without complexity
• Built-in billing removes a major barrier to commercial self-hosting
• Better Auth integration simplifies secure authentication

Frequently Asked Questions

What database does Kaneo use?

The source analysis did not reveal specific database configuration, though the TypeScript API layer in apps/api/src/ suggests an ORM-based approach with typed schema definitions. The workspace, task, and label modules imply relational data patterns typical of PostgreSQL or SQLite deployments.

Can Kaneo run without Redis?

Yes. The WebSocket implementation in apps/api/src/ws/index.ts includes an in-memory adapter suitable for single-instance deployments. Redis is only required for horizontal scaling across multiple API server nodes.

How does Kaneo's billing compare to commercial alternatives?

Kaneo implements seat-based entitlements natively, unlike many open-source project management tools that require external subscription management. The apps/api/src/billing/index.ts module handles checkout flows and feature gating directly, making it viable for SaaS operators who want to offer managed Kaneo instances.

Is Kaneo's frontend framework-agnostic?

The analyzed frontend code in apps/web/src/ demonstrates React-specific patterns using TanStack Query (formerly React Query) for server state management. While the API is standard HTTP/JSON and could support any client, the provided reference implementation is tightly coupled to React's ecosystem.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}