Deploying myTinyTodo

Introduction

myTinyTodo is a simple, open-source to-do list application that delivers essential task management features without unnecessary complexity. Its clean AJAX-powered interface loads quickly and provides a smooth user experience for managing daily tasks, projects, and personal goals.

Despite its minimalist design, myTinyTodo offers surprisingly robust features including multiple lists, tags, priorities, due dates, and search functionality. The application supports both SQLite and MySQL databases, making it flexible enough for personal use or small team deployments.

Key highlights of myTinyTodo:

• Multiple Lists: Organize tasks into separate lists for different projects or contexts
• Tagging System: Categorize tasks with tags for easy filtering and organization
• Priority Levels: Mark tasks as high, medium, or low priority
• Due Dates: Set deadlines with optional reminders
• Drag-and-Drop Sorting: Reorder tasks intuitively with drag-and-drop
• AJAX Interface: Smooth, responsive interface without page reloads
• Search Functionality: Quickly find tasks across all lists
• Notes Support: Add detailed notes to any task
• RSS Feeds: Subscribe to task lists via RSS
• JSON API: Programmatic access for integrations
• Authentication: Optional password protection
• Mobile-Friendly: Responsive design works on all devices
• Open Source: Licensed under GPL

This guide walks through deploying myTinyTodo on Klutch.sh using Docker, configuring the database, and customizing your task management setup.

Why Deploy myTinyTodo on Klutch.sh

Deploying myTinyTodo on Klutch.sh provides several advantages:

Access Anywhere: Your to-do list is accessible from any device with a web browser, anywhere in the world.

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds myTinyTodo without complex configuration.

Persistent Storage: Attach persistent volumes for your database and configuration. Your tasks survive container restarts.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access to your personal tasks.

GitHub Integration: Connect your configuration repository for automatic redeployments.

Minimal Resources: myTinyTodo’s lightweight design runs efficiently with minimal resource allocation.

Custom Domains: Assign a custom domain for easy bookmarking and access.

Prerequisites

Before deploying myTinyTodo on Klutch.sh, ensure you have:

• A Klutch.sh account
• A GitHub account with a repository for your configuration
• Basic familiarity with Docker and containerization concepts
• (Optional) A custom domain for your myTinyTodo instance

Understanding myTinyTodo Architecture

myTinyTodo is built with simplicity in mind:

PHP Backend: A lightweight PHP application handling task management logic and database operations.

SQLite/MySQL Database: Stores all tasks, lists, tags, and settings. SQLite is the default for single-user deployments.

JavaScript Frontend: AJAX-powered interface providing smooth interactions without page reloads.

RESTful API: JSON endpoints for external integrations and automation.

Preparing Your Repository

Create a GitHub repository with your myTinyTodo configuration.

Repository Structure

mytinytodo-deploy/
├── Dockerfile
├── config.php
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in your repository root:

FROM php:8.2-apache

# Install required extensions
RUN docker-php-ext-install pdo pdo_mysql pdo_sqlite

# Enable Apache mod_rewrite
RUN a2enmod rewrite

# Set working directory
WORKDIR /var/www/html

# Download myTinyTodo
RUN apt-get update && apt-get install -y wget unzip \
    && wget -O /tmp/mytinytodo.zip https://github.com/maxpozdeev/mytinytodo/archive/refs/heads/master.zip \
    && unzip /tmp/mytinytodo.zip -d /tmp \
    && mv /tmp/mytinytodo-master/* /var/www/html/ \
    && rm -rf /tmp/mytinytodo* \
    && apt-get clean && rm -rf /var/lib/apt/lists/*

# Create data directory
RUN mkdir -p /var/www/html/db \
    && chown -R www-data:www-data /var/www/html \
    && chmod -R 755 /var/www/html \
    && chmod -R 777 /var/www/html/db

# Copy custom configuration if exists
COPY config.php /var/www/html/db/config.php

# Expose port
EXPOSE 80

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
    CMD curl -f http://localhost/ || exit 1

Creating the Configuration File

Create config.php:

<?php

// myTinyTodo configuration

$config = array(
    // Database type: sqlite or mysql
    'db' => 'sqlite',

    // SQLite database file (relative to db/ directory)
    'sqlite_file' => 'todolist.db',

    // MySQL settings (if using MySQL)
    'mysql' => array(
        'host' => getenv('MYSQL_HOST') ?: 'localhost',
        'db' => getenv('MYSQL_DATABASE') ?: 'mytinytodo',
        'user' => getenv('MYSQL_USER') ?: 'root',
        'password' => getenv('MYSQL_PASSWORD') ?: '',
    ),

    // Password protection (leave empty for no password)
    'password' => getenv('MTT_PASSWORD') ?: '',

    // Timezone
    'timezone' => getenv('TZ') ?: 'UTC',

    // Language (en, ru, de, fr, etc.)
    'lang' => 'en',

    // First day of week: 0 = Sunday, 1 = Monday
    'firstdayofweek' => 1,

    // Date format
    'dateformat' => 'Y-m-d',

    // Show completed tasks
    'showCompleted' => 1,
);

return $config;

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env

Environment Variables Reference

Variable	Required	Default	Description
MTT_PASSWORD	No	-	Password for access protection
TZ	No	UTC	Timezone setting
MYSQL_HOST	If MySQL	-	MySQL server hostname
MYSQL_DATABASE	If MySQL	-	MySQL database name
MYSQL_USER	If MySQL	-	MySQL username
MYSQL_PASSWORD	If MySQL	-	MySQL password

Deploying myTinyTodo on Klutch.sh

Push Your Repository to GitHub

Initialize and push your repository with the Dockerfile and configuration.

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project called “mytinytodo”.

Create a New App

Within your project, create a new app and connect your GitHub repository.

Configure HTTP Traffic

In the deployment settings:

• Select HTTP as the traffic type
• Set the internal port to 80

Set Environment Variables

Configure the following environment variables:

Variable	Value
MTT_PASSWORD	Your chosen password (optional)
TZ	Your timezone (e.g., America/New_York)

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
/var/www/html/db	1 GB	Database and configuration

Deploy Your Application

Click Deploy to start the build process.

Access myTinyTodo

Once deployment completes, access your instance at https://your-app-name.klutch.sh.

Complete Initial Setup

On first access, myTinyTodo will guide you through the initial setup process.

Using myTinyTodo

Creating Lists

Organize your tasks by creating separate lists:

1. Click the “Add list” button
2. Enter a name for your list
3. Click to save

Create lists for different areas:

• Work projects
• Personal tasks
• Shopping lists
• Goals and habits

Adding Tasks

Add tasks quickly with the input field:

1. Type your task title
2. Optionally add metadata inline:
   • #tag to add tags
   • ^priority to set priority (1-3)
   • @date to set due date
3. Press Enter to save

Example: Buy groceries #shopping ^2 @tomorrow

Managing Tasks

Interact with tasks:

• Complete: Click the checkbox to mark done
• Edit: Click the task title to edit
• Priority: Click priority indicator to change
• Notes: Add detailed notes to any task
• Move: Drag and drop to reorder

Using Tags

Tags help organize across lists:

• Add tags when creating tasks with #tagname
• Click tags to filter tasks
• View all tags in the sidebar
• Combine multiple tags for refined filtering

Search

Find tasks quickly:

• Use the search box to find tasks across all lists
• Search by title, notes, or tags
• Results update in real-time as you type

Advanced Configuration

Password Protection

Enable password protection by setting the MTT_PASSWORD environment variable. Users must enter this password to access the interface.

RSS Feeds

Subscribe to task lists via RSS:

• Each list has an RSS feed URL
• Use with feed readers for task updates
• Subscribe to multiple lists for aggregated view

JSON API

Integrate with other applications:

GET /api/tasks.json - Get all tasks
POST /api/task.json - Create a task
PUT /api/task.json - Update a task
DELETE /api/task.json - Delete a task

Custom Themes

Customize the appearance:

• Modify CSS in the themes directory
• Create custom color schemes
• Adjust layout and typography

Using MySQL Instead of SQLite

For larger deployments or when you need more robust database features:

1. Provision a MySQL database
2. Update your config.php to use MySQL
3. Set the MySQL environment variables
4. Redeploy the application

Troubleshooting

Database Errors

• Ensure the db directory is writable
• Check file permissions (should be 777 for db directory)
• Verify SQLite extension is installed

Tasks Not Saving

• Check browser console for JavaScript errors
• Verify AJAX requests are completing
• Check PHP error logs

Password Not Working

• Verify MTT_PASSWORD environment variable is set
• Clear browser cache and cookies
• Check that config.php is loading correctly

Slow Performance

• Consider switching from SQLite to MySQL for large task counts
• Enable browser caching
• Optimize database regularly

Additional Resources

• myTinyTodo Official Website
• myTinyTodo GitHub Repository
• myTinyTodo FAQ
• Klutch.sh Persistent Volumes
• Klutch.sh Deployments

Conclusion

Deploying myTinyTodo on Klutch.sh gives you a simple, effective task management solution accessible from anywhere. The clean interface and thoughtful features provide everything needed for personal productivity without unnecessary complexity.

With persistent storage for your tasks, automatic HTTPS, and easy deployment, myTinyTodo on Klutch.sh becomes your reliable, always-available personal to-do list. Whether you’re managing daily errands or tracking long-term projects, myTinyTodo helps you stay organized without getting in your way.