Traggo: Tag-Based Time Tracking

Introduction

Traggo is a modern, tag-based time tracking solution that takes a unique approach to tracking your activities. Unlike traditional time trackers that use rigid project/task hierarchies, Traggo allows you to categorize time entries using flexible tags. Built with Go and React, it offers a fast, lightweight, and highly customizable time tracking experience perfect for developers, freelancers, and anyone who values flexibility.

By the end of this guide, you’ll have a production-ready Traggo installation that:

• Tracks time using flexible tag combinations
• Provides real-time dashboards and statistics
• Supports multiple users with individual tracking
• Offers powerful filtering and search capabilities
• Exports data in various formats
• Includes REST API for automation
• Features a modern, responsive web interface
• Works seamlessly on desktop and mobile

Prerequisites

Before starting, ensure you have:

• A Linux server with at least 512MB RAM
• Docker and Docker Compose installed
• A domain name or subdomain (e.g., time.yourdomain.com)
• Basic understanding of Docker
• At least 2GB free disk space
• Root or sudo access

Why Tag-Based Time Tracking?

Flexibility Over Structure

Traditional time trackers force you into hierarchies:

• Client → Project → Task → Subtask

Traggo lets you tag freely:

• type:development, client:acme, lang:python, urgent:yes
• type:meeting, team:backend, project:api-v2
• personal:true, activity:learning, topic:kubernetes

Multiple Dimensions

Track multiple aspects simultaneously:

• What you’re doing
• Who you’re doing it for
• Which project it belongs to
• What technology you’re using
• How urgent it is
• Where you’re working
• What mood you’re in

Dynamic Reporting

Generate reports across any tag combination:

• Time spent per client
• Languages used this week
• Meeting time vs. coding time
• Urgent tasks across all projects
• Personal time vs. work time

No Pre-Planning Required

Start tracking immediately:

• No need to create projects first
• No complex setup wizards
• No rigid category structures
• Tags evolve with your needs

Architecture Overview

Traggo’s architecture is simple and efficient:

1. Traggo Server: Go-based backend with embedded database
2. Web UI: React-based single-page application
3. SQLite Database: Embedded database for data storage
4. Optional Reverse Proxy: For HTTPS and custom domains

Data flow:

• Users interact with React web UI
• UI communicates with Go backend via REST API
• Backend stores data in SQLite database
• Real-time updates via WebSocket
• Export data on-demand

Directory Structure Setup

Create the necessary directory structure:

mkdir -p ~/traggo/{data,backups,scripts}
cd ~/traggo

The data directory will store:

• SQLite database
• User avatars
• Configuration files
• Application state

Docker Compose Configuration

Create a docker-compose.yml file:

version: '3.8'

services:
  traggo:
    image: traggo/server:latest
    container_name: traggo
    restart: unless-stopped
    ports:
      - "3030:3030"
    environment:
      TRAGGO_DEFAULT_USER_NAME: admin
      TRAGGO_DEFAULT_USER_PASS: changeme_secure_password
      TRAGGO_PORT: 3030
      TRAGGO_LOG_LEVEL: info
      TRAGGO_DATABASE_DIALECT: sqlite3
      TRAGGO_DATABASE_CONNECTION: /data/traggo.db
    volumes:
      - ./data:/data
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3030/api/v1/health"]
      interval: 30s
      timeout: 10s
      retries: 3

Important Configuration Notes:

1. Change TRAGGO_DEFAULT_USER_PASS to a secure password
2. This creates an initial admin user
3. Additional users can be created from the web interface
4. SQLite is used by default (no separate database needed)

Environment Variables:

• TRAGGO_DEFAULT_USER_NAME: Initial admin username
• TRAGGO_DEFAULT_USER_PASS: Initial admin password
• TRAGGO_PORT: Port to listen on (default: 3030)
• TRAGGO_LOG_LEVEL: debug, info, warn, error
• TRAGGO_DATABASE_DIALECT: sqlite3 or postgres
• TRAGGO_DATABASE_CONNECTION: Database path or connection string

Starting Traggo

Start the service:

docker-compose up -d

Verify container is running:

docker-compose ps

Check logs:

docker-compose logs -f traggo

Wait for:

• “Starting server on port 3030”
• “Database migration completed”

Initial Setup and Login

Access Traggo

Navigate to http://YOUR-SERVER-IP:3030

You should see the Traggo login page with a clean, modern interface.

First Login

Login with default credentials:

• Username: admin
• Password: The password you set in TRAGGO_DEFAULT_USER_PASS

You’ll be taken to the dashboard immediately.

Change Admin Password

1. Click your username (top right) → Settings
2. Navigate to Account tab
3. Change Password section
4. Enter current password
5. Enter new password (min 8 characters)
6. Confirm new password
7. Save

Interface Overview

Traggo’s interface has three main sections:

Dashboard:

• Current running timers
• Quick statistics
• Recent time entries
• Tag overview

Time Entries:

• List of all time entries
• Filter by date range
• Search by tags
• Edit/delete entries

Statistics:

• Visual charts and graphs
• Customizable dashboards
• Tag-based reports
• Export options

Setting Up Reverse Proxy

For HTTPS access, use Caddy or Nginx.

Option 1: Caddy (Recommended)

Create caddy/Caddyfile:

time.yourdomain.com {
    encode gzip

    reverse_proxy traggo:3030 {
        header_up X-Real-IP {remote_host}
        header_up X-Forwarded-For {remote_host}
        header_up X-Forwarded-Proto {scheme}
    }

    # WebSocket support for real-time updates
    @websocket {
        header Connection *Upgrade*
        header Upgrade websocket
    }

    # Security headers
    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains"
        X-Content-Type-Options "nosniff"
        X-Frame-Options "SAMEORIGIN"
        X-XSS-Protection "1; mode=block"
        Referrer-Policy "strict-origin-when-cross-origin"
    }

    log {
        output file /data/access.log
        format json
    }
}

Add Caddy to docker-compose.yml:

  caddy:
    image: caddy:latest
    container_name: traggo_caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./caddy/Caddyfile:/etc/caddy/Caddyfile:ro
      - ./caddy/config:/config
      - ./caddy/data:/data
    depends_on:
      - traggo

Update and restart:

docker-compose up -d

Access at https://time.yourdomain.com

Option 2: Nginx

Create nginx/nginx.conf:

server {
    listen 80;
    server_name time.yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name time.yourdomain.com;

    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;

    location / {
        proxy_pass http://traggo:3030;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    # Security headers
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
}

Understanding Tags

Tag Basics

Tags in Traggo consist of key-value pairs:

Format: key:value

Examples:

• project:website-redesign
• type:meeting
• client:acme-corp
• language:python
• priority:high
• location:office
• billable:yes

Tag Organization

Organize tags by category:

Activity Type:

• type:development
• type:meeting
• type:research
• type:documentation
• type:review

Client/Project:

• client:client-name
• project:project-name
• component:api
• component:frontend

Technology:

• lang:python
• lang:javascript
• framework:react
• framework:django

Metadata:

• billable:yes or billable:no
• urgent:yes or urgent:no
• location:office or location:home
• mood:productive or mood:distracted

Tag Hierarchies

Create logical tag hierarchies:

Project Structure:

client:acme
└── project:website
    ├── component:frontend
    ├── component:backend
    └── component:database

Activity Breakdown:

type:development
├── lang:python
├── lang:javascript
└── lang:go

type:meeting
├── team:backend
├── team:frontend
└── team:all-hands

Tag Best Practices

1. Consistent Naming: Use lowercase, hyphens for spaces
2. Meaningful Keys: Choose descriptive key names
3. Limited Keys: Don’t create too many tag keys
4. Reuse Values: Use same values across entries
5. Document Tags: Keep a reference of your tag schema

Time Tracking Workflow

Starting a Timer

Quick Start:

1. Click “Start Timer” button
2. Timer starts immediately
3. Add tags while running or after stopping

Start with Tags:

1. Click “Start Timer”
2. Add tags before starting
   • Type tag key: project
   • Type tag value: website
   • Press Enter or click Add
3. Add more tags as needed
4. Click Start

Multiple Tags Example:

project:website
type:development
lang:javascript
component:frontend
billable:yes

Managing Running Timers

View current timers in dashboard:

• See elapsed time
• View current tags
• Stop timer
• Add/remove tags while running
• Add notes/description

Edit Running Timer:

1. Click on running timer
2. Add or remove tags
3. Add description
4. Continue or stop

Stopping Timers

Stop Current Timer:

1. Click Stop button
2. Timer creates time entry
3. Entry appears in time entries list
4. Time is calculated automatically

Auto-Stop:

• Configure auto-stop after X hours
• Prevents forgetting to stop timers
• Configurable in Settings

Manual Time Entries

Add entries manually:

1. Navigate to Time Entries
2. Click “Add Entry”
3. Set start time
4. Set end time (or duration)
5. Add tags
6. Add description (optional)
7. Save

Use Cases:

• Forgot to track time
• Tracking past activities
• Adjusting entries
• Offline work

Editing Time Entries

Modify existing entries:

1. Time Entries list
2. Click entry to edit
3. Modify:
   • Start/end time
   • Tags
   • Description
4. Save changes

Bulk Operations:

• Select multiple entries
• Add tag to all
• Remove tag from all
• Delete multiple entries

Tag Management

Creating Tag Keys

Define your tag schema:

1. Settings → Tags
2. Add Tag Key
3. Enter key name: client
4. Optional: Set color
5. Optional: Add description
6. Save

Pre-defined Keys (Example):

• project
• client
• type
• lang
• billable
• location
• priority
• team

Tag Suggestions

Enable tag autocomplete:

1. Start typing tag key
2. Suggestions appear based on:
   • Previously used keys
   • Previously used values for that key
   • Frequency of use
3. Select from suggestions or type new

Tag Colors

Assign colors to tags for visual identification:

1. Settings → Tags
2. Edit tag key
3. Choose color
4. Color appears in:
   • Time entries list
   • Dashboard widgets
   • Statistics charts

Tag Validation

Optional: Require specific tags:

Use Cases:

• Enforce billable tag on all entries
• Require project tag
• Mandate type classification

Configure in Settings → Tags:

• Mark tag as required
• Users must add this tag to time entries

Dashboard Customization

Dashboard Widgets

Add widgets to track different metrics:

Available Widgets:

• Running Timers: Current active timers
• Today’s Time: Total time tracked today
• This Week: Weekly summary
• Tag Distribution: Pie chart of time by tag
• Timeline: Visual timeline of entries
• Recent Entries: Latest time entries
• Statistics: Custom statistics

Add Widget:

1. Dashboard → Add Widget
2. Select widget type
3. Configure filters
4. Set date range
5. Choose visualization
6. Save

Custom Statistics

Create custom stats dashboards:

1. Statistics → New Dashboard
2. Name your dashboard
3. Add chart panels:
   • Pie chart: Time by tag value
   • Bar chart: Compare tag values
   • Line chart: Time over period
   • Table: Detailed breakdown
4. Configure each panel:
   • Select tag key
   • Set date range
   • Choose aggregation
   • Set colors

Example Dashboards:

Work Overview:

• Time by project
• Billable vs. non-billable
• Time by client
• Weekly trends

Development Stats:

• Time by programming language
• Frontend vs. backend time
• Code vs. meetings
• Component breakdown

Personal Productivity:

• Focus time vs. distractions
• Location analysis
• Mood tracking
• Priority distribution

Date Range Filters

Filter data by date:

Quick Ranges:

• Today
• Yesterday
• This Week
• Last Week
• This Month
• Last Month
• This Year

Custom Range:

• Select start date
• Select end date
• Apply filter

Relative Ranges:

• Last 7 days
• Last 30 days
• Last 90 days

Reporting and Analytics

Time Reports

Generate comprehensive reports:

Navigate to Statistics:

Report Types:

1. Tag Value Reports:

• Select tag key (e.g., project)
• See time spent per value
• Visual pie or bar chart
• Export to CSV

2. Time Distribution:

• View time across multiple tag dimensions
• Compare tag combinations
• Identify patterns
• Find time sinks

3. Timeline Reports:

• Visual timeline of activities
• See how time is distributed across day
• Identify productive hours
• Track context switching

4. Comparison Reports:

• Compare time periods
• Week over week
• Month over month
• Trend analysis

Exporting Data

Export time data in various formats:

Export Formats:

• CSV: Import into Excel/Sheets
• JSON: Programmatic access
• Traggo Format: Backup/transfer

Export Options:

1. Navigate to Export section
2. Select date range
3. Choose format
4. Apply filters (optional)
5. Download file

CSV Export Columns:

• Start time
• End time
• Duration
• Tags (one column per tag key)
• Description
• User

Use Cases:

• Import into billing software
• Analyze in spreadsheets
• Create custom reports
• Archive historical data
• Backup time entries

Advanced Filtering

Filter time entries precisely:

Filter Options:

• Date range
• Specific tags
• Tag combinations
• Exclude tags
• User (multi-user setups)
• Description search

Complex Filters:

Show entries where:
  project = "website"
  AND type = "development"
  AND billable = "yes"
  AND date between "2025-01-01" and "2025-01-31"

Saved Filters:

1. Create complex filter
2. Save with name
3. Reuse anytime
4. Share with team

User Management

Creating Additional Users

Add team members:

1. Settings → Users
2. Create New User
3. Enter username
4. Set initial password
5. Assign role (Admin or User)
6. Save

User Roles:

• Admin: Full access, manage users, system settings
• User: Track own time, view own data

User Permissions

Configure what users can see:

Privacy Options:

• Users see only their own time entries
• Admins see all users’ data
• Shared dashboards (optional)
• Export permissions

Multi-User Workflows

Effective team time tracking:

Individual Tracking:

• Each user tracks their own time
• Personal dashboards
• Individual statistics
• Private time entries

Team Aggregation:

• Admins view team totals
• Project time across all users
• Team productivity metrics
• Resource allocation

Shared Tags:

• Consistent tag schema across team
• Shared tag definitions
• Standardized reporting
• Consolidated analytics

API Integration

Enable API Access

Traggo provides a REST API for automation.

Get API Token:

1. Settings → Account → API Token
2. Click “Generate Token”
3. Copy token securely
4. Use for API authentication

Authentication:

curl -H "Authorization: Bearer YOUR_API_TOKEN"   https://time.yourdomain.com/api/v1/timers

API Endpoints

Timers:

List Running Timers:

GET /api/v1/timers

Start Timer:

POST /api/v1/timers
{
  "tags": [
    {"key": "project", "value": "website"},
    {"key": "type", "value": "development"}
  ]
}

Stop Timer:

DELETE /api/v1/timers/{id}

Time Entries:

List Entries:

GET /api/v1/entries?start=2025-01-01&end=2025-01-31

Create Entry:

POST /api/v1/entries
{
  "start": "2025-01-15T09:00:00Z",
  "end": "2025-01-15T10:30:00Z",
  "tags": [
    {"key": "project", "value": "api"},
    {"key": "type", "value": "development"}
  ]
}

Update Entry:

PUT /api/v1/entries/{id}
{
  "tags": [
    {"key": "project", "value": "api"},
    {"key": "billable", "value": "yes"}
  ]
}

Delete Entry:

DELETE /api/v1/entries/{id}

Integration Examples

Command-Line Timer:

Create a bash script for quick tracking:

#!/bin/bash
# start-timer.sh

API_TOKEN="your_api_token"
API_URL="https://time.yourdomain.com/api/v1"

PROJECT="$1"
TYPE="$2"

curl -X POST "$API_URL/timers"   -H "Authorization: Bearer $API_TOKEN"   -H "Content-Type: application/json"   -d "{
    "tags": [
      {"key": "project", "value": "$PROJECT"},
      {"key": "type", "value": "$TYPE"}
    ]
  }"

echo "Timer started for $PROJECT - $TYPE"

Usage:

./start-timer.sh website development

Stop Timer Script:

#!/bin/bash
# stop-timer.sh

API_TOKEN="your_api_token"
API_URL="https://time.yourdomain.com/api/v1"

# Get running timer ID
TIMER_ID=$(curl -s "$API_URL/timers"   -H "Authorization: Bearer $API_TOKEN" |   jq -r '.[0].id')

# Stop timer
curl -X DELETE "$API_URL/timers/$TIMER_ID"   -H "Authorization: Bearer $API_TOKEN"

echo "Timer stopped"

Git Hooks Integration:

Track time automatically with Git:

.git/hooks/post-checkout:

#!/bin/bash

BRANCH=$(git branch --show-current)
PROJECT=$(git remote get-url origin | sed 's/.*///' | sed 's/.git//')

# Start timer when checking out branch
curl -X POST "https://time.yourdomain.com/api/v1/timers"   -H "Authorization: Bearer $API_TOKEN"   -H "Content-Type: application/json"   -d "{
    "tags": [
      {"key": "project", "value": "$PROJECT"},
      {"key": "branch", "value": "$BRANCH"},
      {"key": "type", "value": "development"}
    ]
  }"

Browser Extension:

Build custom browser extension:

• Inject timer controls into web apps
• Track time on specific websites
• Automatic tagging based on URL
• Quick timer start/stop

Backup and Restore

Backup Strategy

Create automated backups:

Create scripts/backup-traggo.sh:

#!/bin/bash

BACKUP_DIR="./backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_NAME="traggo_backup_$TIMESTAMP"

mkdir -p "$BACKUP_DIR"

echo "Backing up Traggo database..."

# Stop traggo container for consistent backup
docker-compose stop traggo

# Copy database file
cp ./data/traggo.db "$BACKUP_DIR/$BACKUP_NAME.db"

# Backup entire data directory
tar -czf "$BACKUP_DIR/$BACKUP_NAME.tar.gz" -C ./data .

# Start traggo
docker-compose start traggo

# Compress backup
gzip "$BACKUP_DIR/$BACKUP_NAME.db"

# Keep only last 30 backups
ls -t "$BACKUP_DIR"/traggo_backup_*.db.gz | tail -n +31 | xargs -r rm
ls -t "$BACKUP_DIR"/traggo_backup_*.tar.gz | tail -n +31 | xargs -r rm

echo "Backup completed: $BACKUP_DIR/$BACKUP_NAME.*"
echo "Backup size: $(du -h $BACKUP_DIR/$BACKUP_NAME.tar.gz | cut -f1)"

Make executable:

chmod +x scripts/backup-traggo.sh

Automated Backups

Schedule daily backups:

crontab -e

Add:

0 3 * * * cd /path/to/traggo && ./scripts/backup-traggo.sh >> ./backups/backup.log 2>&1

Restore Procedure

Create scripts/restore-traggo.sh:

#!/bin/bash

if [ -z "$1" ]; then
    echo "Usage: $0 backup_file.tar.gz"
    exit 1
fi

BACKUP_FILE="$1"

echo "Stopping Traggo..."
docker-compose down

echo "Backing up current data..."
mv ./data ./data.backup_$(date +%Y%m%d_%H%M%S)

echo "Restoring from backup..."
mkdir -p ./data
tar -xzf "$BACKUP_FILE" -C ./data

echo "Starting Traggo..."
docker-compose up -d

echo "Restore completed!"

Make executable:

chmod +x scripts/restore-traggo.sh

Usage:

./scripts/restore-traggo.sh backups/traggo_backup_20250115_030000.tar.gz

Export for Migration

Export all data for migration:

1. Navigate to Export
2. Select “All Time” date range
3. Export as JSON
4. Save file securely
5. Import on new instance

Troubleshooting

Common Issues

Issue: Cannot access Traggo

# Check container status
docker-compose ps

# Check logs
docker-compose logs traggo

# Verify port is accessible
curl http://localhost:3030/api/v1/health

# Check if port is in use
sudo netstat -tlnp | grep 3030

Issue: Login fails

1. Verify credentials
2. Check docker logs for errors
3. Reset admin password:

   docker-compose down
   # Remove database to reset
   rm ./data/traggo.db
   docker-compose up -d
   # Recreates with default credentials

Issue: Tags not saving

1. Check browser console for errors
2. Verify database is writable:

   ls -la ./data/traggo.db

3. Check container logs:

   docker-compose logs traggo | grep -i error

Issue: Timers not starting

1. Clear browser cache
2. Check WebSocket connection (browser dev tools)
3. Verify reverse proxy WebSocket config
4. Test without reverse proxy

Issue: Statistics not loading

1. Check date range is valid
2. Verify time entries exist in range
3. Clear application cache
4. Check browser console for errors

Database Maintenance

Check database size:

ls -lh ./data/traggo.db

Vacuum database (reclaim space):

docker exec traggo sqlite3 /data/traggo.db "VACUUM;"

Database integrity check:

docker exec traggo sqlite3 /data/traggo.db "PRAGMA integrity_check;"

Export all data (backup):

docker exec traggo sqlite3 /data/traggo.db .dump > traggo_dump.sql

Performance Optimization

For large datasets:

1. Regular database vacuuming
2. Archive old time entries
3. Limit dashboard widgets
4. Use date range filters
5. Export and archive yearly data

Optimize SQLite:

docker exec traggo sqlite3 /data/traggo.db "PRAGMA optimize;"

Logs and Debugging

View application logs:

docker-compose logs -f traggo

Enable debug logging:

Edit docker-compose.yml:

      TRAGGO_LOG_LEVEL: debug

Restart:

docker-compose restart traggo

Check specific errors:

docker-compose logs traggo | grep -i error
docker-compose logs traggo | grep -i warning

Advanced Usage

PostgreSQL Database

For larger deployments, use PostgreSQL:

Create docker-compose.yml with PostgreSQL:

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    container_name: traggo_db
    restart: unless-stopped
    environment:
      POSTGRES_DB: traggo
      POSTGRES_USER: traggo
      POSTGRES_PASSWORD: secure_password_here
    volumes:
      - ./postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "traggo"]
      interval: 30s
      timeout: 10s
      retries: 3

  traggo:
    image: traggo/server:latest
    container_name: traggo
    restart: unless-stopped
    depends_on:
      - postgres
    environment:
      TRAGGO_DEFAULT_USER_NAME: admin
      TRAGGO_DEFAULT_USER_PASS: secure_password_here
      TRAGGO_PORT: 3030
      TRAGGO_LOG_LEVEL: info
      TRAGGO_DATABASE_DIALECT: postgres
      TRAGGO_DATABASE_CONNECTION: host=postgres user=traggo password=secure_password_here dbname=traggo sslmode=disable
    volumes:
      - ./data:/data
    ports:
      - "3030:3030"

Tag Automation

Automate tag assignments:

Browser Automation:

• Use browser extension to detect current app
• Auto-tag based on active window
• Track time per application

IDE Integration:

• VSCode extension for Traggo
• Auto-start timer on project open
• Tag by workspace/project name

Calendar Integration:

• Import calendar events
• Auto-create time entries from meetings
• Tag by meeting type/attendees

Custom Analytics

Export data for custom analysis:

Python Analysis:

import pandas as pd
import requests

API_URL = "https://time.yourdomain.com/api/v1"
API_TOKEN = "your_token"

# Fetch time entries
response = requests.get(
    f"{API_URL}/entries",
    headers={"Authorization": f"Bearer {API_TOKEN}"},
    params={"start": "2025-01-01", "end": "2025-01-31"}
)

# Convert to DataFrame
df = pd.DataFrame(response.json())

# Analyze
print(df.groupby('project')['duration'].sum())

Data Science:

• Time series analysis
• Productivity patterns
• Context switching frequency
• Focus time optimization
• Correlation analysis

Mobile Access

Mobile Web Interface

Traggo is fully responsive:

• Access via mobile browser
• Touch-optimized controls
• Quick timer start/stop
• View statistics on mobile
• Full functionality

Progressive Web App

Install as PWA on mobile:

iOS (Safari):

1. Navigate to Traggo URL
2. Tap Share icon
3. “Add to Home Screen”
4. Confirm

Android (Chrome):

1. Navigate to Traggo URL
2. Tap menu (three dots)
3. “Add to Home Screen”
4. Confirm

Mobile Shortcuts

Create quick actions:

iOS Shortcuts:

• Start/stop timer via Siri
• Quick project selection
• Voice-activated tracking

Android Tasker:

• Location-based timer start
• NFC tag triggers
• Automated time tracking

Best Practices

Tag Naming Conventions

Establish consistent naming:

Guidelines:

• Use lowercase
• Hyphens for multi-word values
• Consistent key names
• Meaningful abbreviations
• Date format: YYYY-MM-DD

Examples:

Good:
  project:website-redesign
  type:development
  client:acme-corp

Avoid:
  Project:Website Redesign
  TYPE:dev
  Client: Acme Corp

Regular Review

Schedule weekly reviews:

1. Review time entries
2. Verify tags are accurate
3. Identify time sinks
4. Adjust workflows
5. Update tag schema if needed

Data Privacy

Protect your time data:

1. Use HTTPS only
2. Strong passwords
3. Regular backups
4. Limit user access
5. Export data periodically
6. Review API tokens

Conclusion

You now have a fully functional tag-based time tracking system with:

• Flexible tag-based categorization
• Real-time tracking and dashboards
• Comprehensive statistics and reporting
• Multi-user support
• REST API for automation
• Modern, responsive interface
• Self-hosted privacy and control

Traggo provides a unique approach to time tracking that adapts to your workflow rather than forcing you into rigid structures.

Next Steps

Consider these enhancements:

• Set up automated backups to cloud storage
• Create custom API integrations
• Build browser extensions for specific workflows
• Implement calendar integrations
• Configure monitoring and alerting
• Explore data visualization with external tools
• Create team tag standards documentation
• Set up SSO/LDAP authentication (requires custom build)

For support and updates, visit:

• Traggo Website: https://traggo.net
• Traggo GitHub: https://github.com/traggo/server
• Documentation: https://traggo.net/documentation/
• Community Discussions: https://github.com/traggo/server/discussions