Manage My Damn Life: a self-hosted CalDAV frontend for tasks and calendars

The gap MMDL fills between a CalDAV server and a usable task list

A CalDAV server stores tasks and events as iCalendar objects. It rarely gives you a good way to look at them. Nextcloud, Radicale and Baikal all speak the protocol, but the daily experience of scanning a long VTODO list, grouping it by context, or seeing how tasks overlap in time is left to whatever client you install. MMDL is a web frontend for exactly that layer: it connects to your existing CalDAV accounts and renders tasks as a list, on a calendar, or in a Gantt view. The README lists subtasks, filters, multiple CalDAV accounts and multiple user accounts as first-class features.

The intended user is someone who already self-hosts the storage and does not want to move it. MMDL does not become your data store for tasks; it sits in front of servers the README names as tested: Nextcloud, Radicale and Baikal. CalDAV access goes through the tsdav library, so the project's own compatibility claim is bounded by what tsdav supports. If your server works with tsdav, the README's position is that it should work here too.

How MMDL talks to CalDAV: Next.js, Sequelize and a local cache

The repository is a Next.js application in JavaScript, not TypeScript, with a jsconfig.json and a global.d.ts at the top level. Its package.json pulls in tsdav for CalDAV, ical.js and ical-toolkit for parsing iCalendar data, and dexie with dexie-react-hooks for an in-browser IndexedDB store. That combination tells you where state lives: CalDAV is the source of truth for tasks and events, and Dexie holds a client-side working copy so the interface does not re-fetch everything on each render.

Server-side state is separate. The presence of models/, migrations/, .sequelizerc and runSequelizeMigrations.js shows a Sequelize-managed relational database for application data such as user accounts and CalDAV account configuration, not for your tasks. Authentication is handled through NextAuth with the Sequelize adapter, and keycloak-js and OAuth documentation point at external identity providers as an option. The frontend stack is MUI plus Bootstrap, FullCalendar for calendar rendering, and gantt-task-react for the Gantt view. None of that is exotic, which is the point: the interesting design decision is keeping task data in CalDAV and only account and user metadata in the local database.

Installing MMDL and connecting a first CalDAV account

The README points installation at docs/install/index.md and ships a docker-compose.yml.sample at the repository root. The Dockerfile is a multi-stage Next.js build on node:20.10-alpine, with a separate runner stage that creates a non-root nextjs user and copies the files needed for Sequelize migrations. There is also a buildandrundocker.sh script. The sample environment file is sample.env.local, and the package.json exposes migration scripts that the container relies on.

If you build from source rather than Docker, the scripts are the entry points. Install dependencies, then run the migrations before starting the server, because the Sequelize models expect the tables to exist.

npm install
npm run migrate
npm run dev

According to the package.json, npm run migrate runs npx sequelize-cli db:migrate --env local, and npm run migrate-sqlite runs the same command with --env sqlite. The two environments exist because the sample configuration supports more than one database backend. For a SQLite setup, use the second script instead:

npm run migrate-sqlite

After the server is up, the workflow described in the README is: create a user account, add a CalDAV account, and let MMDL pull the task lists and calendars that account exposes. OAuth is a separate path. The README states that Google Calendars is supported through OAuth and links a guide at docs/Feature%20Guide/GoogleCaldav.md. That guide is where the client ID and redirect details live; the README itself does not spell them out.

Beta status and the production data warning

The README opens with a warning in bold: the project is in beta state, so be careful if you are working with production data. That sentence is the most important line in the repository. A CalDAV frontend writes back to your server, which means a bug in task editing or recurrence handling can damage records that your phone and desktop clients also depend on. Version 0.10.0 in package.json against a latest release of v0.9.3 is a reminder that the versioning is not tightly coupled to releases.

The feature list also carries an implicit limitation. The README lists "support all fields for VTODO and VEVENT as described in RFC 5545" under planned features, not under features. So the current implementation covers many fields, including due, status, description and recurrence, but not the whole specification. If your workflow depends on a less common property, check whether MMDL round-trips it before you trust it with a real task list.

Mobile is the other boundary. The README calls the view "responsive-ish" and states directly that this is a desktop first project, recommending JTX Boards and OpenTasks for mobile instead. Anyone looking for a phone-first task manager is looking at the wrong project.

Where MMDL fits against a native CalDAV client

The obvious alternative is a native CalDAV task client on each device, with no server component at all. Those clients talk straight to the CalDAV server and store nothing in the middle. MMDL's approach is different: it runs a Next.js server with its own database for accounts and configuration, keeps a Dexie cache in the browser, and gives you a shared web view that any browser on your network can open. That buys you a consistent interface across machines and a place to add views, filters and a Gantt chart that a thin native client would not attempt.

The cost is operational. A native client has no migrations, no container, no environment file and no upgrade path. MMDL has all four. The trade is only worth making if the web interface is what you actually want, for example because you switch between machines or because you want task views your existing clients do not render. Self-hosted CalDAV web frontends with a similar shape exist, but the README does not compare MMDL to any of them, so a direct feature comparison is not something this repository documents.

Maintenance, upgrades and the GPL-3.0 licence

The last push to the default branch was on 2026-08-13, and the most recent tagged release is v0.9.3 from 2026-07-11, with v0.9.2 and v0.9.1 in the two months before that. The repository is not archived. On that evidence the project is receiving commits and releases, though the release cadence is not something the README commits to.

Upgrade cost is mostly the database. Because models/ and migrations/ are versioned with the code, an upgrade can require running migrations before the new application code starts, which is why the Dockerfile copies migration files into the runner stage. The package.json also provides npm run undo-migrate and npm run undo-migrate-sqlite for rolling a migration back, a detail worth knowing before you upgrade a working instance. Neither the README nor the release notes describe a supported downgrade path for the application itself, so the migration undo scripts are the only documented rollback mechanism.

The project is licensed GPL-3.0. That matters if you plan to modify MMDL and distribute the result, because the licence carries copyleft obligations. Running it privately on your own server is a different situation from shipping a modified version to others. For the specifics of your case, read the LICENSE file in the repository or consult a lawyer; this is not legal advice.

Editorial conclusion

Adopt MMDL if you already run a CalDAV server such as Nextcloud, Radicale or Baikal and want subtasks, saved filters and a Gantt view without handing your task list to a hosted service. Skip it if you need a mobile-first client, since the README describes the project as desktop first and points mobile users at JTX Boards and OpenTasks. Before pointing it at real data, verify the migration step against your own database: run npm run migrate-sqlite or npm run migrate, confirm the Sequelize migrations in migrations/ applied, and only then connect a CalDAV account.

Frequently asked questions

Official sources

1. intri-in/manage-my-damn-life-nextjs on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases