Why Developers Hate Traditional HR Tools

And why we built something better

Commercial HR Platforms

Black box systems with zero transparency
Cannot audit, customize, or extend functionality
Vendor lock-in with proprietary data formats
Sales-driven feature bloat nobody uses
Web 2.0 interfaces from 2010
No API or terrible API with usage limits

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 on roadmap, direct DB access today

# 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                        │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
│  │   Nginx      │  │   Django     │  │ PostgreSQL   │     │
│  │  (Optional)  │─▶│   Web App    │─▶│   Database   │     │
│  │   Reverse    │  │  Gunicorn    │  │   Persistent │     │
│  │    Proxy     │  │  WhiteNoise  │  │    Volume    │     │
│  └──────────────┘  └──────────────┘  └──────────────┘     │
│         │                   │                             │
│         │                   │                             │
│         ▼                   ▼                             │
│  ┌──────────────┐  ┌──────────────┐                       │
│  │   Admins     │  │   SMTP       │                       │
│  │  Dashboard   │  │   Server     │                       │
│  └──────────────┘  └──────────────┘                       │
│                                                           │
│  ┌─────────────────────────────────────────────┐          │
│  │ External (Optional)                         │          │
│  │   - External SMTP (SendGrid, Mailgun, etc)  │          │
│  └─────────────────────────────────────────────┘          │
└───────────────────────────────────────────────────────────┘

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.

Dreyfus Stages: Novice → Advanced Beginner → Competent → Proficient → Expert

Maps naturally to Junior → Mid-Level → Senior → Staff → Principal engineering levels

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 Development: REST API with authentication, GraphQL support, webhooks

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

Customization Examples

Real ways teams have extended Blik

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.

Slack Integration

Send review invitations via Slack DM instead of email. Post reminders to team channels. Notify managers when reports ready. Slash command to check review status.

GitHub Integration

Pull contribution metrics for code review competencies. Link review cycles to promotion processes. Export reports to Markdown for GitHub wikis.

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

Near-Term (Q1 2025)

REST API for integrations. PDF report export. Historical trend analysis. LDAP/SSO authentication. Multi-language UI support. Performance optimizations.

Mid-Term (Q2-Q3 2025)

GraphQL API. Advanced analytics dashboards. Custom competency builder UI. Workflow automation. Integration marketplace. Mobile app (optional).

Long-Term Vision

Multi-tenant SaaS version (still open source). Plugin architecture for extensions. Team collaboration features. AI coaching suggestions. Open ecosystem of integrations.

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, but it's on the roadmap. Currently, extend by modifying the Django apps directly (it's open source). For custom features, fork and merge in updates from main branch. Plugin architecture planned for 2025 to make extensions cleaner. Until then, Django's app system provides good modularity.

What's the performance like at scale?

Tested with 500 users and 50 concurrent review cycles without issues. Django is fast enough for this use case. PostgreSQL handles the data volume easily. For 1000+ employees, you might want query optimization and caching. Redis for caching is on the roadmap. Most orgs will never hit performance limits.

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?

Currently community-supported via GitHub issues. Paid support options are being explored for 2025. For now, the codebase is clean enough that competent Django developers can self-support. Many companies deploy and maintain it internally.

360 Feedback for Teams That Ship Code