Traggo

Traggo is a lightweight, self‑hosted time‑tracking service that eschews traditional task hierarchies in favor of a pure tag‑based model. Every recorded span of activity is an immutable time interval annotated with a set of key/value tags (e.g., project:alpha, type:meeting). This paradigm gives developers a flexible schema that can be shaped on the fly, enabling fine‑grained reporting without altering database tables or migrations. The core API exposes CRUD operations on time spans and tags, while the web UI consumes these endpoints to render lists, calendars, and customizable dashboards built from user‑defined tag combinations.

Architecture & Technical Stack

Traggo is written in Go (Golang), leveraging the language’s static binaries and excellent concurrency model. The server exposes a RESTful JSON API, built with the net/http standard library and augmented by minimal third‑party routers (e.g., gorilla/mux). Data persistence is handled by PostgreSQL, accessed through the idiomatic database/sql driver with a thin ORM layer (sqlx) for convenience. Authentication is JWT‑based, and user management is straightforward: a single table stores hashed passwords (bcrypt) and role metadata. The front‑end is a single‑page application written in React (or a similar framework), served as static assets compiled from the same repository, allowing seamless integration and rapid iteration.

Containerization is first‑class: a Dockerfile builds a single, stateless image that can be run behind any reverse proxy (NGINX, Traefik). The image pulls the latest PostgreSQL instance as a dependency or accepts an external database URL, making it suitable for Kubernetes deployments via Helm charts or plain Docker Compose.

Core Capabilities & API

• Tag‑based CRUD: Create, read, update, delete time spans with arbitrary tag sets. Tags are stored as a JSONB column for fast querying.
• Query Language: The API supports filter expressions (project=alpha AND type!=meeting) and aggregation endpoints that return daily/weekly/monthly summaries per tag group.
• Webhooks & Events: External services can subscribe to events (timespan.created, timespan.updated) via configurable HTTP callbacks, enabling integrations with CI pipelines or billing systems.
• Extensible Dashboards: Users can compose dashboards by selecting tag aggregations and chart types; the backend exposes a lightweight DSL that translates into SQL GROUP BY queries.
• CLI & SDK: A Go‑based command line tool and a client library (available as a Go package) allow developers to script time entries or embed Traggo logic into larger tooling pipelines.

Deployment & Infrastructure

Running Traggo locally is as simple as pulling the Docker image and pointing it to a PostgreSQL instance. For production, it scales horizontally by running multiple stateless instances behind a load balancer; the database remains the single source of truth. The use of PostgreSQL’s native JSONB and full‑text search features keeps the system performant even with millions of time spans. Health checks expose Prometheus metrics (request latency, error rates) for observability.

Integration & Extensibility

Because the entire data model is tag‑centric, integrating Traggo into existing workflows is painless: any system that can emit timestamps (e.g., IDE plugins, task runners) can POST to the /timespans endpoint with a chosen tag set. The webhook system allows real‑time synchronization with external dashboards or reporting tools. Developers can also fork the repository, add custom tags, or extend the API with new endpoints; the modular Go codebase encourages contribution without breaking backwards compatibility.

Developer Experience

The project’s documentation is thorough, covering installation, configuration, API reference, and developer setup. Configuration is driven by environment variables or a YAML file, keeping secrets out of the repo. The community is active on GitHub Issues and Discussions, with rapid response times for feature requests and bug reports. The codebase follows Go best practices (modular packages, unit tests with coverage badges), and the CI pipeline ensures every PR passes linting, static analysis, and unit tests before merging.

Use Cases

• Freelance & Consulting: Tag time by client and project to generate accurate invoices automatically.
• Agile Teams: Use type tags (design, code, review) to analyze velocity without a dedicated task tracker.
• Personal Productivity: Track daily activities with arbitrary tags (exercise, reading) and visualize habits over time.
• DevOps Pipelines: Emit build or deployment spans to correlate infrastructure costs with development effort.

Advantages

Traggo’s pure tag model eliminates schema migrations and task‑management overhead, giving developers a clean, adaptable API. Its Go implementation delivers high performance and low memory footprint, while PostgreSQL’s advanced querying keeps analytics fast. Being self‑hosted ensures data privacy and compliance, a key requirement for many organizations. Finally, the open‑source license (MIT) and active community provide flexibility and confidence for production deployments.