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

> Explore Kaneo's core features including project management, real-time collaboration, SSO, and integrations. This technical deep dive covers the open-source Kanban platform's robust functionality.

- Repository: [kaneo.app/kaneo](https://github.com/usekaneo/kaneo)
- Tags: deep-dive
- Published: 2026-08-05

---

**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`](https://github.com/usekaneo/kaneo/blob/main/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:

```typescript
// 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 });
}

```

```typescript
// 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`](https://github.com/usekaneo/kaneo/blob/main/apps/api/src/label/index.ts) exposes full CRUD plus assignment operations:

```typescript
// 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}`);
}

```

```typescript
// 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`](https://github.com/usekaneo/kaneo/blob/main/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:

```typescript
// 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`](https://github.com/usekaneo/kaneo/blob/main/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:

```typescript
// 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`);
}

```

```typescript
// 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`](https://github.com/usekaneo/kaneo/blob/main/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`](https://github.com/usekaneo/kaneo/blob/main/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`](https://github.com/usekaneo/kaneo/blob/main/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`](https://github.com/usekaneo/kaneo/blob/main/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`](https://github.com/usekaneo/kaneo/blob/main/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`](https://github.com/usekaneo/kaneo/blob/main/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.