← All articles
a computer screen with a program running on it

Huly: Self-Hosted Project Management That Rivals Linear and Jira

Productivity 2026-02-15 · 7 min read project-management issue-tracking collaboration docker open-source
By Selfhosted Guides Editorial Team — Self-hosting practitioners covering open source software, home lab infrastructure, and data sovereignty.

Most self-hosted project management tools feel like they're five years behind the commercial competition. You get the basic features, but the UI looks like it was designed by committee in 2016, the performance makes you reach for a coffee while pages load, and the "modern" features are always "coming soon." Then there's Linear — gorgeous, fast, opinionated — but cloud-only, $8/seat/month, and your data lives on someone else's servers.

Photo by Rahul Mishra on Unsplash

Huly breaks that pattern. It's an open-source, self-hosted workspace that genuinely feels like a modern SaaS product. Issue tracking that rivals Linear. Documents that rival Notion. Built-in chat that replaces Slack for project discussions. Even an HR module with time tracking. All running on your own hardware.

Huly project management platform logo

What Huly Actually Is

Huly is not another half-baked Jira clone. It's built by the team at Huly (formerly Hardcore Engineering), and it takes the "all-in-one workspace" idea seriously. Here's what you get in a single deployment:

The key insight is that all of these modules share the same data model. An issue mentioned in a document automatically links. A chat message about a pull request connects back to the issue. Time tracked on an issue shows up in HR reports. This integration is where Huly pulls ahead of running separate tools duct-taped together with webhooks.

Why Self-Host Huly

The obvious reason: data sovereignty. Your issues, documents, and team conversations contain your company's intellectual property, strategy, and internal discussions. Running Huly on your own infrastructure means that data never leaves your control.

But there are practical reasons beyond privacy:

System Requirements

Huly is not a lightweight tool. The full stack includes MongoDB, Elasticsearch, MinIO, PostgreSQL, and several application services. Plan accordingly:

If you're running this on a Raspberry Pi, think again. Huly wants a real server — a small VPS, a NUC, or a Proxmox VM with dedicated resources.

Like what you're reading? Subscribe to Self-Hosted Weekly — free weekly guides in your inbox.

Docker Compose Deployment

The Huly team maintains an official huly-selfhost repository that makes deployment straightforward. This is the recommended approach.

git clone https://github.com/hcengineering/huly-selfhost.git
cd huly-selfhost

The repo includes a docker-compose.yaml and a .env file you'll need to customize. The core stack looks like this:

services:
  mongodb:
    image: mongo:7
    volumes:
      - ./data/mongodb:/data/db
    restart: unless-stopped

  elasticsearch:
    image: elasticsearch:7.14.2
    environment:
      - discovery.type=single-node
      - ES_JAVA_OPTS=-Xms512m -Xmx512m
    volumes:
      - ./data/elastic:/usr/share/elasticsearch/data
    restart: unless-stopped

  minio:
    image: minio/minio
    command: server /data --console-address ":9001"
    volumes:
      - ./data/minio:/data
    restart: unless-stopped

  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: huly
      POSTGRES_PASSWORD: changeme
      POSTGRES_DB: huly_account
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    restart: unless-stopped

  huly-server:
    image: hardcoreeng/huly-server:latest
    depends_on:
      - mongodb
      - elasticsearch
      - minio
      - postgres
    restart: unless-stopped

  huly-front:
    image: hardcoreeng/huly-front:latest
    ports:
      - "8083:8083"
    depends_on:
      - huly-server
    restart: unless-stopped

This is simplified — the actual docker-compose.yaml in the repo includes additional services like the collaborator (real-time sync), the account service, Rekoni (text processing), and Love (video calls). Use the official file and just edit the .env:

# Edit the .env file with your domain and secrets
nano .env

# Start everything
docker compose up -d

After startup, access Huly at http://your-server:8083. The first user to create an account becomes the workspace owner.

Post-Install Configuration

A few things to set up after your first login:

  1. Create your workspace — Huly is multi-workspace capable. Create one for your team.
  2. Set up departments — If you're using the HR module, define your org structure.
  3. Configure integrations — Huly supports GitHub integration for linking PRs to issues, and Telegram integration for notifications.
  4. Put it behind a reverse proxy — Use Caddy, Nginx, or Traefik to add HTTPS. Huly needs WebSocket support for real-time features, so make sure your proxy config handles upgrades.
  5. Back up your data — MongoDB dumps, MinIO bucket sync, and PostgreSQL backups. Automate this from day one.

How Huly Compares

Here's where I'll be opinionated, because the project management space is crowded and the right tool depends entirely on your situation.

Huly vs. Linear — Linear is beautifully designed and buttery smooth. If your team is 5-10 people and you're happy paying $8/seat, Linear is hard to beat for pure issue tracking. But Linear is cloud-only, has no self-hosted option, and gives you zero control over your data. Huly gets you 90% of the Linear experience with full data ownership. The trade-off is that Huly's UI, while good, isn't quite as polished as Linear's — few things are.

Huly vs. Jira — Jira is the enterprise default and it shows. It's powerful but bloated, slow, and optimized for "enterprise process" rather than "getting things done." Huly is what Jira would be if someone rebuilt it from scratch in 2024 without the baggage of 20 years of feature creep. If your team doesn't need Jira's advanced workflow automation or its massive integration ecosystem, Huly is a better daily experience.

Huly vs. Plane — Plane is another open-source Linear alternative, and it's solid. But Plane is focused specifically on issue tracking — it doesn't include documents, chat, HR, or video calls. If all you need is issues, Plane is simpler to deploy and run. If you want the all-in-one workspace, Huly is the answer.

Huly vs. Leantime — Leantime is great for non-technical teams who want project management without complexity. It's lighter, simpler, and runs on PHP/MySQL instead of Huly's heavier stack. If you're a small team that just needs kanban boards and timesheets, Leantime is easier to run. Huly is for teams that want the full Linear/Notion/Slack replacement experience and are willing to dedicate server resources to get it.

Huly vs. Vikunja — Vikunja is a task manager, not a project management platform. It's great for personal to-dos and simple team task lists with CalDAV support. Huly is for teams that need sprints, backlogs, documents, and integrated communication. Different tools for different problems.

When Huly Is the Right Choice

Pick Huly if:

Skip Huly if:

Backup Strategy

With multiple data stores, backups require attention:

# MongoDB
docker exec huly-mongodb mongodump --archive=/backup/mongo-$(date +%F).archive

# PostgreSQL
docker exec huly-postgres pg_dump -U huly huly_account > /backup/postgres-$(date +%F).sql

# MinIO (sync to local backup)
docker run --rm -v ./data/minio:/source -v /backup/minio:/dest alpine \
  cp -r /source /dest/minio-$(date +%F)

Run these daily via cron. Test your restores regularly — backups you've never tested are backups that don't work.

The Bottom Line

Huly is the most ambitious open-source project management tool available today. It's not trying to be a simple kanban board or a lightweight task tracker — it's trying to replace your entire project workspace stack. And for the most part, it succeeds.

The trade-off is resource requirements. This isn't a single-binary tool that runs on 256 MB of RAM. You need a real server, you need to manage multiple data stores, and you need to keep everything updated. If that sounds like too much, start with Leantime or Plane and scale up when you outgrow them.

But if you're a team currently paying for Linear + Notion + Slack and you have the infrastructure to self-host, Huly consolidates all of that into a single deployment you own completely. No per-seat pricing, no data leaving your network, and a UI that doesn't make you feel like you're using an open-source compromise. That's a compelling pitch.

Get free weekly tips in your inbox. Subscribe to Self-Hosted Weekly