Why Developers Hate Traditional HR Tools

And why we built something better

Commercial HR Platforms

Vendor-managed infrastructure
Customization through supported settings and integrations
Export formats and APIs vary by vendor
Broader HR and performance-management modules
Vendor-provided support and product updates
Check API availability and limits for your chosen plan

Blik Philosophy

Full source code on GitHub, AGPL licensed
Modify anything, extend everything, fork freely
Standard PostgreSQL, export anytime
Does one thing well: 360 feedback
Clean, modern UI built with simplicity
REST API with webhooks available now

# Deploy Blik in three commands

                git clone https://github.com/thijsdezoete/blik.git

                cd blik

                docker compose up -d

# Visit http://localhost:8000/setup/ and you're done

Clean, Customizable Interface

Hover to toggle theme

Team management with granular permissions

Hover to toggle theme

Track invitations and completion status

Technical Architecture

Modern stack with developer-friendly patterns

Django 5.x

Modern Python web framework. Clean MVT architecture. Type hints throughout. Well-structured apps: accounts, reviews, questionnaires, reports, notifications. Follows Django best practices.

PostgreSQL 15+

Robust relational database. UUID primary keys for security. Proper foreign key constraints. Migrations managed with Django ORM. Standard SQL for direct queries and reporting.

Docker Compose

Single-command deployment. Gunicorn WSGI server. WhiteNoise for static files. PostgreSQL container included. Volume mounts for persistence. Production-ready configuration.

Clean Frontend

Django templates with modern CSS. No heavy JavaScript frameworks. Fast page loads. Mobile-responsive. Shadcn-inspired design system. Easy to customize and theme.

Security First

UUID-based tokens prevent enumeration. CSRF protection enabled. Rate limiting ready. SQL injection impossible with ORM. Django security middleware active. Regular dependency updates.

System Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                         Docker Compose Stack                        │
│                                                                     │
│  ┌──────────────┐         ┌──────────────┐         ┌──────────────┐│
│  │   Nginx      │         │   Django     │         │ PostgreSQL   ││
│  │  (Optional)  │────────▶│   Web App    │────────▶│   Database   ││
│  │   Reverse    │  :80    │  Gunicorn    │  :5432  │   Persistent ││
│  │    Proxy     │  :443   │  WhiteNoise  │         │    Volume    ││
│  └──────────────┘         └──────┬───────┘         └──────────────┘│
│                                  │                                 │
│                                  │                                 │
│              ┌───────────────────┼───────────────────┐             │
│              │                   │                   │             │
│              ▼                   ▼                   ▼             │
│    ┌──────────────────┐ ┌──────────────┐  ┌──────────────────┐   │
│    │ Admin Dashboard  │ │  REST API    │  │  Email Service   │   │
│    │  /dashboard/     │ │  /api/v1/    │  │  Django SMTP     │   │
│    │  - Settings      │ │  - CRUD ops  │  │  or External     │   │
│    │  - Teams         │ │  - Webhooks  │  │  (SendGrid, etc) │   │
│    │  - Cycles        │ │  - API Docs  │  └──────────────────┘   │
│    │  - Reports       │ └──────┬───────┘                          │
│    └──────────────────┘        │                                  │
│                                │ Async Webhooks (threaded)        │
│                                │                                  │
└────────────────────────────────┼──────────────────────────────────┘
                                 │
                                 ▼
            ┌────────────────────────────────────────┐
            │   External Integrations (Your Code)    │
            │                                        │
            │  ┌──────────────────────────────────┐  │
            │  │  Webhook Endpoints               │  │
            │  │  - cycle.created                 │  │
            │  │  - feedback.submitted            │  │
            │  │  - report.generated              │  │
            │  │  HMAC-SHA256 verified            │  │
            │  └──────────────────────────────────┘  │
            │                                        │
            │  ┌──────────────────────────────────┐  │
            │  │  API Clients                     │  │
            │  │  - Bearer token auth             │  │
            │  │  - Organization scoped           │  │
            │  │  - Rate limiting ready           │  │
            │  └──────────────────────────────────┘  │
            │                                        │
            │  ┌──────────────────────────────────┐  │
            │  │  BI/Analytics Tools              │  │
            │  │  - Direct PostgreSQL access      │  │
            │  │  - Metabase, Grafana, etc        │  │
            │  └──────────────────────────────────┘  │
            └────────────────────────────────────────┘

Key Architecture Features:
  • Async webhook delivery (non-blocking, threaded)
  • UUID-based tokens prevent enumeration attacks
  • Organization-scoped multi-tenancy
  • REST API with OpenAPI/Swagger docs at /api/docs/
  • Django signals for event-driven architecture
  • Fixture-based default questionnaires (auto-loaded on migrate)

Code Quality and Development Experience

Built to read, understand, and extend

Clean Codebase

PEP 8 compliant. Black formatting. Type hints on functions. Meaningful variable names. Comments where complexity exists. No "clever" code that requires a PhD to understand.

Well-Documented

README covers deployment. REQUIREMENTS.md explains architecture. Docstrings on complex functions. Inline comments for tricky logic. Deployment guide for production. Contribution guidelines.

Modular Structure

Django apps for separation of concerns. Core, accounts, reviews, questionnaires, reports, notifications. Each app focuses on one domain. Easy to understand where code lives.

Testing Ready

Pytest configuration included. Model tests easy to write. View tests straightforward. Integration test examples. CI/CD templates on roadmap. Test coverage improving with contributions.

Database Migrations

Django migrations track schema changes. Automatic migration generation. Forward and backward compatible. Tested on PostgreSQL. Can review migration SQL before applying.

Environment Configuration

12-factor app methodology. .env file for configuration. Environment variables for secrets. Sensible defaults for development. Production settings clearly documented.

Dreyfus Model for Technical Growth

Competency framework that resonates with engineers

Why Dreyfus for Developers

Five-stage model from Novice to Expert aligns with how engineers actually develop skills. No corporate HR jargon. Maps to technical career ladders naturally. Based on research, not management fads.

Learn about the Dreyfus Model →

Default Questionnaires

Professional Skills: leadership, communication, collaboration, problem-solving. Software Engineering: code quality, architecture, debugging, mentoring. Both use Dreyfus model ratings.

See the full framework →

Customizable Competencies

Create your own competency frameworks. Add domain-specific skills. Adjust rating scales. Include free-text questions. Framework is flexible, not prescriptive.

Contribution Opportunities

Help make Blik better for everyone

Easy First Issues

Frontend: UI improvements, mobile responsive fixes, accessibility enhancements

Backend: Additional email providers, export formats, questionnaire templates

Docs: Deployment guides, troubleshooting, translation

Medium Complexity

Features: PDF export, LDAP integration, custom branding, email scheduling

Testing: Unit tests, integration tests, E2E test suite

Performance: Database query optimization, caching layer

Advanced Projects

API Enhancement: GraphQL support, extended webhook events

AI Enhancement: Local model support (Llama, Mistral), multi-model comparison

Analytics: Historical trends, team analytics, visualization dashboards

# Contributing is straightforward

                git clone https://github.com/thijsdezoete/blik.git

                cd blik
# Make your changes, add tests

                pytest
# Open PR with clear description

                git push origin feature/your-improvement

# AGPL license means your improvements help everyone

Ideas for Extending Blik

Possible customizations for self-hosted deployments. These are development ideas, not included integrations.

Custom Competency Frameworks

Replace default competencies with company-specific values and technical skills. Create frameworks per role (IC, EM, PM). Import competencies from CSV for bulk setup.

Contribution Idea: Slack Integration

A potential contribution could send review invitations and reminders through Slack. There is no shipped Slack or Teams integration.

Contribution Idea: GitHub Integration

A custom integration could connect code-review context to a review cycle. Blik does not ship a GitHub connector or Markdown report export.

Custom Themes

Replace CSS with company branding. Add logo to emails and reports. Customize color scheme to match internal tools. White-label for multi-tenant deployments.

Advanced Analytics

Connect BI tools directly to PostgreSQL. Build custom dashboards in Metabase or Grafana. Export data to data warehouse. Track trends across multiple cycles.

Multi-Language Support

Translate UI to team's language. Django i18n framework ready. Community contributions for translations. RTL language support possible.

Why AGPL License Matters

Real open source, not open-core

True Freedom

Fork and modify without permission. Use internally without restrictions. No enterprise upsell for features. Community contributions benefit everyone, not just vendor.

Copyleft Protection

AGPL prevents proprietary forks. If someone offers Blik as a service, they must share improvements. Protects community investment. Ensures improvements flow back.

No Relicensing Risk

Cannot become closed-source later. Community controls direction. No MongoDB/Elastic-style license switches. Your investment is protected by copyleft.

AGPL TL;DR

Use freely internally. Modify as needed. If you offer it as a service, share your changes. Perfect for protecting community-driven projects.

Roadmap and Community

Where we're going and how to get involved

Shipped

Structured review cycles and four ready-made questionnaires.
Trend reports, peer benchmarks and percentiles, and perception-gap insights.
GDPR self-service JSON export and deletion tools.
REST API with Bearer token authentication and OpenAPI documentation.
Four HMAC-signed webhook events.
API throttling: 100 requests/hour anonymously and 1,000/hour per token.
Organization-scoped access and managed EU hosting.

View API Documentation

Planned

These are development directions, not features included in today's product or delivery commitments.

PDF report export.
LDAP, SSO, and SAML authentication.
Native HRIS, Slack, and Teams integrations.
Multi-language interface and additional manager analytics.
Usage analytics, workflow automation, and a plugin system.
Native mobile app.

GitHub

Source Code & Issues

Discord

Community Chat

Docs

Documentation Site

Weekly

Release Cadence

Technical FAQ

Why Django instead of Rails/Node.js/Go?

Django brings mature ecosystem, excellent ORM, built-in admin interface, and security features by default. Python is widely known. Django has been battle-tested for 15+ years. The admin panel alone saves months of development. Type hints and async support in modern Django. For this use case, Django is the pragmatic choice.

Can I use MySQL/MariaDB instead of PostgreSQL?

PostgreSQL is the only officially supported database. MySQL lacks some features we use (proper JSON fields, advanced constraints). You could fork and adapt for MySQL, but we recommend PostgreSQL for reliability and feature set. PostgreSQL is included in Docker setup, so there's no extra work.

How do I contribute code?

Fork the repo, create a feature branch, make your changes, add tests, update docs if needed, and open a pull request. Include clear description of what and why. Follow existing code style (Black formatting). All PRs reviewed by maintainers. Small, focused PRs merge faster than large refactors.

Is there a plugin system for extensions?

Not yet. A plugin system is planned without a release date. For now, extend the Django apps directly in your fork and merge upstream updates as needed.

What's the performance like at scale?

Runs comfortably on a 1 GB VPS for typical team sizes (512 MB minimum).

How do updates work? Will they break my customizations?

Standard git workflow. Pull latest main, review changes, test locally, deploy. Django migrations handle database changes automatically. If you've customized code, merge conflicts are possible. Keep customizations minimal or in separate branch. Consider contributing custom features back so they're maintained upstream.

Is there commercial support available?

Self-hosted users can use GitHub issues for community support. Hosted SaaS includes email support; Enterprise includes priority support and an SLA. Compare hosted plans for the current limits and terms.

360 Feedback for Teams That Ship Code