Deploying a Donetick App

Introduction

Donetick is an open-source task and chore management application that transforms how you and your household stay organized. Built with Go and React, Donetick offers a modern, intuitive interface for creating tasks, managing recurring chores, and collaborating with family members or roommates. Whether you’re splitting household duties, tracking personal to-do lists, or coordinating with a team, Donetick provides the flexibility and features you need.

What sets Donetick apart is its natural language processing for task creation—simply describe what you need to do in plain English like “Take the trash out every Monday and Tuesday at 6:15 pm” and Donetick automatically extracts dates, times, and recurrence patterns. With features like assignee rotation, gamification through a points system, multi-factor authentication, and support for OAuth2 providers, Donetick is both powerful and secure.

Deploying Donetick on Klutch.sh with a Dockerfile gives you a self-hosted solution with complete control over your data, persistent storage for all your tasks and user information, and access from anywhere at klutch.sh/app. Say goodbye to subscription fees and privacy concerns—your tasks, your data, your server.

Why Deploy Donetick on Klutch.sh?

Running Donetick on Klutch.sh offers several advantages for managing your tasks and chores:

Complete Data Ownership — Your tasks, chores, and family data stay on your own server
Persistent Storage — Never lose task history, completion data, or user preferences
Natural Language Processing — Create tasks by describing them in plain English
Collaborative Features — Share tasks with family, friends, or roommates in groups
Automatic Docker Detection — Place your Dockerfile at the root and Klutch.sh handles deployment
Mobile-Friendly — iOS and Android apps available for on-the-go task management
Advanced Scheduling — Daily, weekly, monthly, yearly, or adaptive scheduling based on completion history
Gamification — Built-in points system to motivate task completion
Multi-Factor Authentication — TOTP-based MFA and OAuth2 support for secure access
No Subscription Costs — Self-hosted means no monthly fees for premium features

Prerequisites

Before deploying Donetick, ensure you have:

A Klutch.sh account (sign up here)
A GitHub repository for your Donetick deployment (GitHub is the only supported git source)
Basic understanding of task management concepts
(Optional) OAuth2 provider configured if you want external authentication

For platform onboarding, refer to the Quick Start Guide.

Architecture Overview

Donetick operates as a full-stack application with these key components:

Backend (Go)

RESTful API for all task operations
Natural language processing engine
Task scheduling and recurrence logic
User authentication and authorization
Webhook system for external integrations
SQLite database for data persistence

Frontend (React)

Modern, responsive web interface
Real-time task synchronization
Mobile-optimized views
Dashboard mode for wall-mounted displays
Offline support (limited functionality)

Key Features

Task management with natural language creation
Subtasks with automatic reset on recurrence
Assignee rotation (round-robin, random, or by completion count)
Custom labels and five priority levels
Time tracking for tasks
Photo attachments (local or S3-compatible storage)
NFC tag support for physical triggers
Things (track non-task data like numbers, booleans, or text)

Port Configuration

Donetick web interface serves on port 2021 by default
Select HTTP traffic when deploying on Klutch.sh
Internal port should be set to 2021

Repository Preparation

Step 1: Create Repository Structure

Set up your repository with the following layout:

donetick/
├── Dockerfile              # Must be at repo root for auto-detection
├── .dockerignore          # Exclude unnecessary files
├── .env.example           # Template for environment variables
├── config/
│   └── selfhosted.yaml    # Configuration file
└── README.md              # Documentation

Step 2: Create the Dockerfile

Create a production-ready Dockerfile at your repository root. Klutch.sh automatically detects and uses this file:

# Donetick Task Management Dockerfile
FROM donetick/donetick:latest

# Set environment variables
ENV DT_ENV=selfhosted \
    DT_SQLITE_PATH=/donetick-data/donetick.db

# Create data directory
RUN mkdir -p /donetick-data /config

# Expose web interface port
EXPOSE 2021

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:2021/ || exit 1

# Start Donetick
CMD ["/app/donetick"]

Step 3: Create .dockerignore

Optimize build performance by excluding unnecessary files:

.git
.github
.env
.env.*
!.env.example
*.log
*.db
*.db-shm
*.db-wal
.DS_Store
node_modules
data

Step 4: Create Configuration File

Create config/selfhosted.yaml with your configuration:

# Donetick Self-Hosted Configuration
database:
  type: sqlite
  path: /donetick-data/donetick.db

server:
  port: 2021
  host: 0.0.0.0

auth:
  # JWT secret - generate a secure random string
  jwt_secret: "CHANGE_THIS_TO_A_SECURE_RANDOM_STRING"

  # Session duration in hours
  session_duration: 720

  # Enable/disable registration
  allow_registration: true

  # OAuth2 providers (optional)
  oauth2:
    providers: []
    # Example configuration:
    # - name: authentik
    #   client_id: your-client-id
    #   client_secret: your-client-secret
    #   redirect_url: https://your-app.klutch.sh/api/auth/callback/authentik
    #   authorization_url: https://auth.example.com/application/o/authorize/
    #   token_url: https://auth.example.com/application/o/token/
    #   user_info_url: https://auth.example.com/application/o/userinfo/

# File storage configuration
storage:
  type: local  # Options: local, s3
  local:
    path: /donetick-data/uploads
  # s3:
  #   endpoint: s3.amazonaws.com
  #   bucket: donetick-uploads
  #   region: us-east-1
  #   access_key: your-access-key
  #   secret_key: your-secret-key

# Notification settings
notifications:
  # Telegram
  telegram:
    enabled: false
    bot_token: ""

  # Discord
  discord:
    enabled: false
    webhook_url: ""

  # Pushover
  pushover:
    enabled: false
    app_token: ""
    user_key: ""

# Realtime sync
realtime:
  enabled: true

# Task settings
tasks:
  # Enable NFC tag support
  nfc_enabled: true

  # Default timezone
  timezone: America/New_York

Step 5: Create .env.example

Provide a template for environment variables:

# Donetick Configuration
DT_ENV=selfhosted
DT_SQLITE_PATH=/donetick-data/donetick.db

# JWT Secret (CHANGE THIS!)
JWT_SECRET=generate-a-secure-random-string-here

# Server Configuration
SERVER_PORT=2021

# Registration
ALLOW_REGISTRATION=true

# Timezone
TIMEZONE=America/New_York

# Storage Configuration
STORAGE_TYPE=local
STORAGE_PATH=/donetick-data/uploads

# S3 Storage (Optional)
# S3_ENDPOINT=s3.amazonaws.com
# S3_BUCKET=donetick-uploads
# S3_REGION=us-east-1
# S3_ACCESS_KEY=your-access-key
# S3_SECRET_KEY=your-secret-key

# Cloudflare R2 Storage (Optional)
# S3_ENDPOINT=https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com
# S3_BUCKET=donetick
# S3_REGION=auto
# S3_ACCESS_KEY=your-r2-access-key
# S3_SECRET_KEY=your-r2-secret-key

# Telegram Notifications (Optional)
TELEGRAM_ENABLED=false
TELEGRAM_BOT_TOKEN=

# Discord Notifications (Optional)
DISCORD_ENABLED=false
DISCORD_WEBHOOK_URL=

# Pushover Notifications (Optional)
PUSHOVER_ENABLED=false
PUSHOVER_APP_TOKEN=
PUSHOVER_USER_KEY=

# OAuth2 Configuration (Optional)
# OAUTH2_PROVIDER_NAME=authentik
# OAUTH2_CLIENT_ID=your-client-id
# OAUTH2_CLIENT_SECRET=your-client-secret
# OAUTH2_REDIRECT_URL=https://your-app.klutch.sh/api/auth/callback/authentik
# OAUTH2_AUTHORIZATION_URL=https://auth.example.com/application/o/authorize/
# OAUTH2_TOKEN_URL=https://auth.example.com/application/o/token/
# OAUTH2_USER_INFO_URL=https://auth.example.com/application/o/userinfo/

# Realtime Sync
REALTIME_ENABLED=true

# NFC Support
NFC_ENABLED=true

Step 6: Create README.md

Document your deployment:

# Donetick on Klutch.sh

Open-source task and chore management system for organizing household duties collaboratively.

## Features

- Natural language task creation
- Recurring task scheduling (daily, weekly, monthly, yearly, adaptive)
- Assignee rotation (round-robin, random, by completion count)
- Subtasks with automatic reset
- Custom labels and priorities
- Time tracking
- Photo attachments
- NFC tag support
- Gamification with points system
- Multi-factor authentication
- OAuth2 integration
- Mobile apps (iOS, Android)
- Home Assistant integration
- REST API and webhooks

## Deployment

This repository is configured for deployment on Klutch.sh with automatic Dockerfile detection.

### Environment Variables

Copy `.env.example` and configure with your specific settings before deploying.

**Critical Configuration:**

1. **JWT_SECRET**: Generate a secure random string (minimum 32 characters)
2. **ALLOW_REGISTRATION**: Set to `false` after creating initial accounts if desired
3. **TIMEZONE**: Set to your local timezone for accurate task scheduling

### Local Development

```bash
docker build -t donetick .
docker run -p 2021:2021 -v ./data:/donetick-data -v ./config:/config donetick

Access at http://localhost:2021

Initial Setup

After deployment:

Register your first user account
Create a household/group
Invite family members or roommates
Start creating tasks and chores!

Natural Language Examples

Create tasks using natural language:

“Take the trash out every Monday and Tuesday at 6:15 pm”
“Change water filter every 6 months”
“Water plants every 3 days”
“Clean the garage on the 1st of every month”
“Pay rent on the 1st of each month”

Mobile Apps

iOS: Available on TestFlight (alpha)
Android: APK available in GitHub releases

Documentation

Full documentation available at: https://donetick.com/ Community forum: https://github.com/donetick/donetick/discussions

---

## Deploy Donetick on Klutch.sh

### Step 1: Generate JWT Secret

Before deploying, generate a secure JWT secret. Run this command locally:

```bash
openssl rand -base64 32

Copy the output—you’ll need it for environment variables.

Step 2: Push Repository to GitHub

Commit and push your repository with the Dockerfile to GitHub:

git init
git add .
git commit -m "Initial Donetick deployment"
git remote add origin https://github.com/YOUR_USERNAME/donetick.git
git push -u origin main

Step 3: Create Project on Klutch.sh

Navigate to klutch.sh/app
Click New Project and give it a descriptive name (e.g., "Family Tasks")
Click Add App within your project

Step 4: Configure App Settings

Select Repository: Choose your GitHub repository containing the Dockerfile
Traffic Type: Select HTTP
Internal Port: Set to 2021
Branch: Select main or your deployment branch

Step 5: Configure Environment Variables

Add these essential environment variables in Klutch.sh:

Required Configuration:

DT_ENV=selfhosted
DT_SQLITE_PATH=/donetick-data/donetick.db
JWT_SECRET=your-generated-secret-from-step-1
SERVER_PORT=2021
TIMEZONE=America/New_York (or your timezone)

Optional Settings:

ALLOW_REGISTRATION=true (set to false after creating accounts if desired)
REALTIME_ENABLED=true (enables instant sync across devices)
NFC_ENABLED=true (enables NFC tag support)
STORAGE_TYPE=local (or s3 for cloud storage)

Notification Configuration (Optional):

Telegram:

TELEGRAM_ENABLED=true
TELEGRAM_BOT_TOKEN=your-bot-token

Discord:

DISCORD_ENABLED=true
DISCORD_WEBHOOK_URL=your-webhook-url

Pushover:

PUSHOVER_ENABLED=true
PUSHOVER_APP_TOKEN=your-app-token
PUSHOVER_USER_KEY=your-user-key

S3-Compatible Storage (Optional):

STORAGE_TYPE=s3
S3_ENDPOINT=s3.amazonaws.com
S3_BUCKET=donetick-uploads
S3_REGION=us-east-1
S3_ACCESS_KEY=your-access-key
S3_SECRET_KEY=your-secret-key

Cloudflare R2 Example:

S3_ENDPOINT=https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com
S3_BUCKET=donetick
S3_REGION=auto
S3_ACCESS_KEY=your-r2-access-key
S3_SECRET_KEY=your-r2-secret-key

Step 6: Attach Persistent Storage

Donetick requires persistent storage for the SQLite database, uploads, and configuration:

In your app settings, navigate to Storage
Click Add Volume
Configure the volume:
- Mount Path: /donetick-data
- Size: 5GB (adjust based on expected usage)

This volume stores:

SQLite database (donetick.db)
Task data and user information
Photo attachments (if using local storage)
Task completion history
User preferences and settings

For a household with multiple users and extensive task history, consider 10GB or more.

Step 7: Deploy

Review all settings and environment variables
Click Deploy
Klutch.sh will automatically detect the Dockerfile and build your application
Monitor the build logs for any issues
Once deployed, your app will be available at https://YOUR-APP-NAME.klutch.sh

Step 8: Initial Setup

Visit your deployed app at https://YOUR-APP-NAME.klutch.sh
Click Register to create your first account
Complete the registration form with:
- Username
- Email address
- Secure password
After logging in, you'll see the main dashboard
(Optional) Enable multi-factor authentication:
- Go to Settings → Security
- Enable Two-Factor Authentication
- Scan QR code with authenticator app

Creating Your First Tasks

Quick Task Creation

Donetick’s natural language processing makes task creation effortless:

Step 1: Navigate to Tasks

Click the + Add Task button on the main dashboard.

Step 2: Describe Your Task

Simply type what you need to do in plain English:

Examples:

Take the trash out every Monday and Tuesday at 6:15 pm

Donetick automatically:

Creates a recurring task
Sets it for Mondays and Tuesdays
Schedules it for 6:15 PM
Adds it to your task list

Change water filter every 6 months

Donetick:

Creates a recurring task with 6-month interval
Starts from today’s date
Automatically reschedules after completion

Pay rent on the 1st of every month

Donetick:

Sets up monthly recurrence
Schedules for the 1st of each month
Sends reminders before due date

Manual Task Creation

For more control, use the detailed task form:

Basic Information:

Task Name: Descriptive title
Description: Additional details or notes
Priority: P1 (highest) through P4, or No Priority
Labels: Add custom labels for organization

Scheduling:

Due Date: Select specific date and time
Recurrence: Choose pattern:
- Daily
- Weekly (select specific days)
- Monthly (specific date or day of month)
- Yearly
- Adaptive (learns from completion history)

Assignment:

Assignee: Choose specific person or let Donetick rotate
Rotation Method:
- Round-robin (takes turns)
- Random
- By completion count (fairest distribution)

Advanced Options:

Subtasks: Break task into smaller steps
Time Tracking: Enable to track how long task takes
Photos: Attach reference images
Things: Link to tracked data points
Completion Window: Restrict when task can be marked complete

Creating Groups and Collaboration

Step 1: Create a Group

Groups allow you to share tasks with family, roommates, or teams.

Navigate to Settings → Groups
Click Create New Group
Enter group details:
- Group Name: "Smith Family", "Apartment 3B", etc.
- Description: Brief description of the group
Click Create

Step 2: Invite Members

In your group settings, click Invite Members
Enter email addresses of people to invite
Set their role:
- Admin: Full access to group settings and tasks
- Member: Can view and complete assigned tasks
- Viewer: Read-only access
Click Send Invitations

Members receive email invitations with registration links.

When creating tasks, you can now:

Assign tasks to specific group members
Set up automatic rotation among members
Create group-wide labels
View group task completion statistics

Task Management Features

Subtasks

Break complex tasks into manageable steps:

Creating Subtasks:

Open a task
Click Add Subtask
Enter subtask description
Optionally nest subtasks within subtasks

Subtask Behavior:

Track completion independently
Automatically reset when parent task recurs
Can have their own time tracking
Appear in task completion percentage

Example:

Main Task: Deep Clean Kitchen (Every Saturday)
├─ Subtask: Clean countertops and appliances
├─ Subtask: Mop floor
├─ Subtask: Clean refrigerator
│  ├─ Sub-subtask: Remove expired items
│  └─ Sub-subtask: Wipe down shelves
└─ Subtask: Take out trash and replace bag

Time Tracking

Monitor how long tasks actually take:

Enable Time Tracking:

Open task details
Toggle Time Tracking enabled
Click Start Timer when beginning work
Click Stop Timer when finished

Features:

Multiple sessions per task
View total time across all sessions
Historical time data for recurring tasks
Average completion time calculation

Use Cases:

Estimate future task duration
Identify time-consuming chores
Fairly distribute workload based on time investment
Track productivity improvements

Labels and Organization

Create custom labels for flexible organization:

Creating Labels:

Navigate to Settings → Labels
Click New Label
Configure:
- Name: "Kitchen", "Urgent", "Weekly", etc.
- Color: Choose visual identifier
- Shared: Make available to all group members

Using Labels:

Apply multiple labels to tasks
Filter task list by label
View tasks grouped by label
Create label-specific views

Example Label System:

By Location:
- Kitchen
- Bathroom
- Living Room
- Bedroom
- Garage

By Type:
- Cleaning
- Maintenance
- Shopping
- Administrative
- Pet Care

By Frequency:
- Daily
- Weekly
- Monthly
- Seasonal

Priorities

Donetick supports five priority levels:

P1: Highest priority, urgent tasks
P2: High priority, important but not urgent
P3: Medium priority, routine tasks
P4: Low priority, nice to have
No Priority: Unclassified tasks

Priority Features:

Sort tasks by priority
Visual indicators in task list
Filter views by priority
Set default priorities for labels

Gamification and Points System

Donetick includes a built-in points system to motivate task completion:

How Points Work

Task Completion: Earn points based on task priority
- P1 tasks: 100 points
- P2 tasks: 75 points
- P3 tasks: 50 points
- P4 tasks: 25 points
- No priority: 10 points
Bonus Points:
- Complete before due date: +25%
- Complete all subtasks: +50%
- Maintain streak: +10% per consecutive day

Leaderboards

View group leaderboards to see:

Most points earned
Most tasks completed
Longest completion streak
Category-specific rankings

Achievements

Unlock achievements for:

Completing first task
Maintaining 7-day streak
Completing 100 tasks
Earning 1,000 points
Helping group members

Notifications and Reminders

Stay on top of tasks with flexible notification options:

In-App Notifications

Task due soon (configurable timeframe)
Task overdue
Task assigned to you
Group member completed shared task
Comments on your tasks

Mobile Push Notifications

Available through iOS and Android apps:

iOS App (TestFlight):

Join TestFlight beta program
Install Donetick app from TestFlight
Log in with your credentials
Grant notification permissions

Android App (APK):

Download APK from GitHub Releases
Enable installation from unknown sources
Install APK
Log in and enable notifications

External Notifications

Configure external notification channels:

Telegram:

Create a Telegram bot via @BotFather
Get your bot token
Add environment variable: TELEGRAM_BOT_TOKEN=your-token
Set TELEGRAM_ENABLED=true
In Donetick settings, link your Telegram account

Discord:

Create a Discord webhook in your server settings
Copy webhook URL
Add environment variable: DISCORD_WEBHOOK_URL=your-url
Set DISCORD_ENABLED=true

Pushover:

Create account at pushover.net
Get application token and user key
Add environment variables:
- PUSHOVER_APP_TOKEN=your-token
- PUSHOVER_USER_KEY=your-key
Set PUSHOVER_ENABLED=true

Advanced Features

Things

“Things” let you track data that isn’t a task:

Creating Things:

Navigate to Things section
Click New Thing
Configure:
- Name: "Thermostat Temperature", "Pet Fed Today"
- Type: Number, Boolean, or Text
- Initial Value: Starting value

Use Cases:

Track thermostat settings
Boolean flags (“Did anyone feed the cat?”)
Inventory counts (“Paper towel rolls remaining”)
Notes that multiple people need to see

Linking Things to Tasks:

Automatically complete task when Thing reaches certain value
Update Thing when task is completed
Create task reminders based on Thing value

Example:

Thing: "Dishwasher Status" (Text)
- Empty
- Running
- Ready to unload

Task: "Unload Dishwasher"
- Only appears when Thing = "Ready to unload"
- Automatically completes when Thing changes to "Empty"

NFC Tag Support

Use physical NFC tags to mark tasks complete:

Setting Up NFC Tags:

Purchase NFC tags (NTAG213 or similar)
In Donetick, navigate to task
Click Generate NFC Tag
Use NFC writing app to write generated URL to tag
Place tag in convenient location

Use Cases:

Tag on trash can: “Take out trash”
Tag on pet food container: “Feed pets”
Tag on medicine cabinet: “Take medication”
Tag on thermostat: “Adjust temperature”

How It Works:

Scan NFC tag with phone
Opens Donetick app
Automatically marks associated task complete
Awards points and records completion time

Dashboard Mode

For wall-mounted tablets or shared displays:

Enabling Dashboard Mode:

Log in as admin user
Access Donetick from tablet or large screen
Navigate to Settings → Display
Enable Dashboard Mode

Dashboard Features:

Full-screen task list
Calendar view
Recent activity feed
Quick task completion for any user
User selection menu
Auto-refresh every 60 seconds

Perfect For:

Kitchen tablets
Hallway displays
Common area screens
Shared household devices

Completion Restrictions

Prevent tasks from being marked complete too early:

Setting Restrictions:

Open task details
Click Advanced Options
Set Completion Window:

Options:

Last X Hours Before Due: Task only completable within X hours of due date
After Specific Time: Task completable only after certain time
Date Range: Task completable within specific date range

Use Cases:

Prevent marking “Take out trash” complete until actual trash day
Ensure “Morning medication” is taken in the morning
Verify “Water plants” happens at appropriate intervals

Home Assistant Integration

Integrate Donetick with Home Assistant for smart home automation:

Installation

Install Donetick integration from GitHub
Configure integration with your Donetick URL and API key
Integration creates to-do lists for each user

Features

View tasks in Home Assistant dashboard
Create tasks from Home Assistant
Automate task creation based on sensors
Trigger automations when tasks complete

Example Automations

Trash Day Reminder:

automation:
  - alias: "Remind to take out trash"
    trigger:
      - platform: time
        at: "18:00:00"
      - platform: state
        entity_id: calendar.trash_day
        to: "on"
    action:
      - service: notify.mobile_app
        data:
          message: "Don't forget to take out the trash!"

Create Task When Low on Supplies:

automation:
  - alias: "Add shopping task when low on paper towels"
    trigger:
      - platform: numeric_state
        entity_id: sensor.paper_towel_count
        below: 2
    action:
      - service: donetick.create_task
        data:
          title: "Buy paper towels"
          priority: "P2"
          labels: ["Shopping"]

API and Webhooks

REST API

Donetick provides a full REST API for custom integrations:

Authentication:

Generate API token in settings:

Navigate to Settings → API
Click Generate Token
Copy long-lived access token
Use in API requests as Bearer token

Common API Endpoints:

Get All Tasks:

curl -H "Authorization: Bearer YOUR_TOKEN" \
  https://your-app.klutch.sh/api/tasks

Create Task:

curl -X POST \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "New task",
    "description": "Task description",
    "due_date": "2025-12-20T10:00:00Z",
    "priority": "P2"
  }' \
  https://your-app.klutch.sh/api/tasks

Complete Task:

curl -X POST \
  -H "Authorization: Bearer YOUR_TOKEN" \
  https://your-app.klutch.sh/api/tasks/123/complete

Get Task Details:

curl -H "Authorization: Bearer YOUR_TOKEN" \
  https://your-app.klutch.sh/api/tasks/123

Webhooks

Configure webhooks to trigger external systems:

Creating Webhooks:

Navigate to Settings → Webhooks
Click New Webhook
Configure:
- Name: Descriptive name
- URL: External endpoint
- Events: Task created, completed, updated, deleted
- Secret: Shared secret for validation

Webhook Payload Example:

{
  "event": "task.completed",
  "timestamp": "2025-12-16T15:30:00Z",
  "task": {
    "id": 123,
    "name": "Take out trash",
    "completed_by": {
      "id": 1,
      "username": "john_smith"
    },
    "completed_at": "2025-12-16T15:30:00Z",
    "points_awarded": 50
  }
}

Use Cases:

Send custom notifications to external services
Log task completion in analytics platform
Trigger smart home actions
Update external project management tools

OAuth2 Integration

Connect Donetick with external authentication providers:

Supported Providers

Donetick supports any OAuth2 provider with OIDC (OpenID Connect):

Authentik
Authelia
Keycloak
Okta
Auth0
Google OAuth
GitHub OAuth

Configuration Example (Authentik)

Step 1: Create Application in Authentik

Log into Authentik admin panel
Navigate to Applications → Providers
Create new OAuth2/OIDC Provider
Configure:
- Name: Donetick
- Client Type: Confidential
- Redirect URIs: https://your-app.klutch.sh/api/auth/callback/authentik
- Signing Key: Select certificate
Save and copy Client ID and Client Secret

Step 2: Configure Donetick

Update config/selfhosted.yaml:

auth:
  oauth2:
    providers:
      - name: authentik
        client_id: your-client-id
        client_secret: your-client-secret
        redirect_url: https://your-app.klutch.sh/api/auth/callback/authentik
        authorization_url: https://auth.example.com/application/o/authorize/
        token_url: https://auth.example.com/application/o/token/
        user_info_url: https://auth.example.com/application/o/userinfo/

Or use environment variables:

OAUTH2_PROVIDER_NAME=authentik
OAUTH2_CLIENT_ID=your-client-id
OAUTH2_CLIENT_SECRET=your-client-secret
OAUTH2_REDIRECT_URL=https://your-app.klutch.sh/api/auth/callback/authentik
OAUTH2_AUTHORIZATION_URL=https://auth.example.com/application/o/authorize/
OAUTH2_TOKEN_URL=https://auth.example.com/application/o/token/
OAUTH2_USER_INFO_URL=https://auth.example.com/application/o/userinfo/

Step 3: Test Login

Restart Donetick
Navigate to login page
Click Sign in with Authentik
Authenticate with Authentik
Redirected back to Donetick, logged in

Backup and Recovery

Protect your task data with regular backups:

Manual Backup

Create backups of your SQLite database:

Step 1: Access Volume

Your database is stored in the persistent volume at /donetick-data/donetick.db.

Step 2: Download Database

Use Klutch.sh’s volume management to download the database file, or connect via SSH if available.

Step 3: Store Securely

Keep backups in a secure location:

Local encrypted drive
Cloud storage (encrypted)
Off-site backup service

Automated Backup Script

Create a backup script for regular backups:

#!/bin/bash

# Backup script for Donetick database
BACKUP_DIR="/path/to/backups"
DATE=$(date +%Y%m%d_%H%M%S)
DB_PATH="/donetick-data/donetick.db"

# Create backup directory if it doesn't exist
mkdir -p $BACKUP_DIR

# Create backup with timestamp
cp $DB_PATH "$BACKUP_DIR/donetick_backup_$DATE.db"

# Compress backup
gzip "$BACKUP_DIR/donetick_backup_$DATE.db"

# Keep only last 30 days of backups
find $BACKUP_DIR -name "donetick_backup_*.db.gz" -mtime +30 -delete

echo "Backup completed: donetick_backup_$DATE.db.gz"

Restore from Backup

Step 1: Stop Application

In Klutch.sh dashboard, stop the Donetick application.

Step 2: Replace Database

Access the persistent volume
Replace donetick.db with your backup file
Ensure file permissions are correct

Step 3: Restart Application

Start the Donetick application. All your tasks and data will be restored.

What Gets Backed Up

The SQLite database contains:

All tasks and chores
User accounts and settings
Task completion history
Points and achievements
Labels and priorities
Group memberships
Things data
Webhooks and API keys

Note: Photo attachments stored locally are in /donetick-data/uploads/. Back up this directory separately if using local storage. If using S3-compatible storage, photos are already backed up in your S3 bucket.

Troubleshooting

Common issues and solutions:

Application Won’t Start

Issue: Donetick container fails to start

Solution:

Check build logs in Klutch.sh dashboard for errors
Verify all required environment variables are set:
- DT_ENV=selfhosted
- DT_SQLITE_PATH=/donetick-data/doneticz.db
- JWT_SECRET is set and non-empty
Ensure persistent volume is attached to /donetick-data
Check volume has write permissions
Review application logs for specific error messages

Can’t Register New User

Issue: Registration form shows error

Solutions:

If Registration Disabled:

Check environment variable: ALLOW_REGISTRATION=true
Redeploy application after changing setting

If JWT Secret Missing:

Ensure JWT_SECRET environment variable is set
Generate new secret: openssl rand -base64 32
Add to environment variables and redeploy

Natural Language Parsing Not Working

Issue: Tasks created with plain text don’t extract dates

Solution:

The natural language parser looks for specific patterns. Try these formats:

For Recurrence:

“every Monday”
“every Monday and Wednesday”
“every 3 days”
“every week”
“every month on the 15th”
“every 6 months”

For Time:

“at 6:00 pm”
“at 09:00”
“at noon”

Combined Example:

Take trash out every Monday at 7:00 pm
Water plants every 3 days at 8:00 am
Pay bills on the 1st of every month

Database Locked Error

Issue: “Database is locked” error when accessing tasks

Solution:

SQLite database is being accessed by multiple processes
Wait a moment and refresh page
If persistent:
- Restart Donetick application
- Check for database corruption: sqlite3 donetick.db "PRAGMA integrity_check;"
- If corrupted, restore from backup

Notifications Not Sending

Issue: Telegram/Discord/Pushover notifications not received

Solutions:

Telegram:

Verify bot token is correct
Ensure TELEGRAM_ENABLED=true
Start conversation with bot first (send /start)
Link Telegram account in Donetick settings

Discord:

Verify webhook URL is correct and active
Ensure DISCORD_ENABLED=true
Test webhook directly with curl

Pushover:

Verify both app token and user key are correct
Ensure PUSHOVER_ENABLED=true
Check Pushover app is installed on device

Issue: Can’t log in with OAuth2 provider

Solutions:

Verify redirect URL matches exactly in both provider and Donetick config
Check client ID and client secret are correct
Ensure all OAuth2 URLs (authorization, token, user info) are correct
Check OAuth2 provider allows your Donetick URL as redirect
Review provider logs for authentication errors

Mobile App Won’t Connect

Issue: iOS/Android app can’t connect to server

Solutions:

Verify server URL is correct (include https://)
Ensure server is accessible from internet
Check firewall rules allow mobile IP addresses
Try accessing web interface from mobile browser first
Clear app cache and data, try again

Performance Optimization

Optimize Donetick for larger households:

Database Optimization

Regular Maintenance:

Run SQLite optimization commands periodically:

-- Vacuum database to reclaim space
VACUUM;

-- Analyze database for query optimization
ANALYZE;

-- Check integrity
PRAGMA integrity_check;

Indexing:

Donetick automatically creates indexes, but verify they exist:

-- Check indexes
SELECT name FROM sqlite_master WHERE type='index';

Storage Management

Photo Attachments:

For households with many photo attachments:

Consider using S3-compatible storage instead of local
Implement photo size limits
Compress photos before upload
Periodically clean up photos from deleted tasks

Database Size:

Monitor database growth:

# Check database file size
ls -lh /donetick-data/donetick.db

For very large databases (>1GB):

Consider archiving completed tasks older than 1 year
Increase volume size in Klutch.sh
Optimize database more frequently

Caching

Enable caching for better performance:

Browser Caching:

Donetick automatically sets cache headers for static assets. Ensure browser caching is enabled.

API Response Caching:

For heavy API usage, consider implementing caching layer.

Security Best Practices

Protect your Donetick installation:

Strong Authentication

Require Strong Passwords:

Minimum 12 characters
Mix of uppercase, lowercase, numbers, symbols
No common words or patterns

Enable Multi-Factor Authentication:

All users should enable MFA
Use authenticator apps like:
- Authy
- Google Authenticator
- Microsoft Authenticator
- 1Password

Use OAuth2 When Possible:

External authentication providers like Authentik offer:

Centralized access control
Advanced security features
Single sign-on (SSO)
Better audit logging

API Security

Protect API Tokens:

Generate separate tokens for each integration
Store tokens securely (never in code repositories)
Rotate tokens periodically
Revoke tokens when no longer needed

Webhook Security:

Always use HTTPS for webhook endpoints
Validate webhook signatures using shared secret
Implement rate limiting on webhook receivers
Log all webhook deliveries for auditing

Network Security

HTTPS Only:

Always access Donetick via https://your-app.klutch.sh
Never use HTTP for production
Klutch.sh automatically provides SSL certificates

Access Control:

Disable registration after all users are created (ALLOW_REGISTRATION=false)
Review group member permissions regularly
Remove inactive users promptly
Monitor access logs for suspicious activity

Data Security

Regular Backups:

Automated daily backups
Store backups encrypted
Keep backups off-site
Test restoration process periodically

Sensitive Data:

Don't store sensitive information in task descriptions
Use encrypted fields for sensitive notes
Be cautious with photo attachments containing personal data

Production Checklist

Before going live with Donetick, verify:

Pre-Deployment

Repository contains Dockerfile at root
config/selfhosted.yaml configured with production values
Strong JWT secret generated (minimum 32 characters)
Environment variables set in Klutch.sh
Persistent volume attached (5GB minimum)
Timezone configured correctly
Storage type selected (local or S3)

Security

JWT secret is unique and secure
Strong password policy enforced
Multi-factor authentication enabled for admin users
Registration disabled after initial setup (if desired)
HTTPS access verified
API tokens generated securely
Webhook secrets configured

Features

Natural language task creation tested
Recurring tasks working correctly
Group creation and invitations functional
Assignee rotation configured
Labels created and organized
Priorities assigned to tasks
Notification channels tested (if configured)

Optional

OAuth2 provider configured and tested
S3-compatible storage configured (if using)
Mobile apps installed and connected
Home Assistant integration configured
Webhooks configured for external systems
NFC tags written and tested

Backup

Performance

Database optimized
Storage usage monitored
Load times acceptable
Mobile app performance good

Additional Resources

Official Documentation

Community

Mobile Apps

Integrations

Conclusion

Donetick on Klutch.sh provides a powerful, self-hosted solution for managing household tasks and chores collaboratively. With natural language processing, flexible scheduling, gamification, and extensive integration options, you can create a task management system that fits your exact needs.

By following this guide, you’ve learned how to:

✅ Deploy Donetick with a production-ready Dockerfile
✅ Configure persistent storage for task data
✅ Create tasks using natural language
✅ Set up groups and collaborative features
✅ Implement advanced scheduling and assignee rotation
✅ Enable notifications through multiple channels
✅ Integrate with OAuth2 providers
✅ Use the API and webhooks for custom automations
✅ Secure your installation with best practices
✅ Back up and restore your data

Your Donetick installation is now ready to help you and your household stay organized, motivated, and on top of all your tasks and chores. The self-hosted approach gives you complete control, privacy, and the ability to customize every aspect of your task management workflow.

Start creating tasks, invite your family members, and watch as Donetick transforms how your household manages daily responsibilities. With features like assignee rotation, gamification, and mobile apps, everyone will be engaged and motivated to complete their share of the work.

Deploying a Donetick App

Introduction

Why Deploy Donetick on Klutch.sh?

Prerequisites

Architecture Overview

Repository Preparation

Step 1: Create Repository Structure

Step 2: Create the Dockerfile

Step 3: Create .dockerignore

Step 4: Create Configuration File

Step 5: Create .env.example

Step 6: Create README.md

Initial Setup

Natural Language Examples

Mobile Apps

Documentation

Step 2: Push Repository to GitHub

Step 3: Create Project on Klutch.sh

Step 4: Configure App Settings

Step 5: Configure Environment Variables

Step 6: Attach Persistent Storage

Step 7: Deploy

Step 8: Initial Setup

Creating Your First Tasks

Quick Task Creation

Manual Task Creation

Creating Groups and Collaboration

Step 1: Create a Group

Step 2: Invite Members

Step 3: Share Tasks with Group

Task Management Features

Subtasks

Time Tracking

Labels and Organization

Priorities

Gamification and Points System

How Points Work

Leaderboards

Achievements

Notifications and Reminders

In-App Notifications

Mobile Push Notifications

External Notifications

Advanced Features

Things

NFC Tag Support

Dashboard Mode

Completion Restrictions

Home Assistant Integration

Installation

Features

Example Automations

API and Webhooks

REST API

Webhooks

OAuth2 Integration

Supported Providers

Configuration Example (Authentik)

Backup and Recovery

Manual Backup

Automated Backup Script

Restore from Backup

What Gets Backed Up

Troubleshooting

Application Won’t Start

Can’t Register New User

Natural Language Parsing Not Working

Database Locked Error

Notifications Not Sending

OAuth2 Login Fails

Mobile App Won’t Connect

Performance Optimization

Database Optimization

Storage Management

Caching

Security Best Practices

Strong Authentication

API Security

Network Security

Data Security