IT-Case — Building a Python/Django Development Team

Project Context

IT-Case — an Ekaterinburg-based IT company specializing in web development and business process automation. By 2013, the company faced a typical growing business problem: shortage of qualified developers to handle the increasing flow of projects.

Business objective:

• Expand development team by 7-10 people
• Focus on Python/Django stack (company's main direction)
• Willingness to train junior specialists (shortage of seniors in the market)
• Build a process that scales for future hiring

Hiring challenges in 2013:

• Python specialist shortage in Ekaterinburg (technology was still gaining popularity)
• Competition for seniors — large companies poached experienced developers
• Lack of structure — recruiting was chaotic, without a process
• High early attrition — poor onboarding led to newcomer turnover

Objective

My role — Technical Recruiter with focus on:

1. Sourcing & Screening — finding candidates and initial filtering
2. Technical interviewing — assessing professional skills
3. Developing training program — onboarding and adaptation of new employees
4. Building process — creating reproducible recruiting pipeline

Project peculiarity: willingness to invest in junior/middle specialists with training, instead of expensive senior hiring due to market shortage.

Solution

1. Building Technical Recruiting Process

Sourcing Strategy:

┌─────────────────────────────────────────────┐
│         Candidate Search Channels           │
├─────────────────────────────────────────────┤
│ 1. Job boards (hh.ru, habr.com/career)      │
│ 2. Professional communities (Python UG)     │
│ 3. University partnerships (UrFU, UrGUPS)   │
│ 4. GitHub sourcing (Python activity)        │
│ 5. Referrals (team recommendations)         │
└─────────────────────────────────────────────┘

Sourcing features:

• Expanded criteria: not just "Django knowledge", but general programming skills, willingness to learn, pet project portfolio
• GitHub as indicator: open source activity and personal Python projects — strong signal
• University recruiting: partnerships with universities to attract graduates and senior students
• Community involvement: participation in Python User Group meetups for networking

2. Structured Technical Interview

Selection funnel:

4-stage selection process:

Stage 1: Screening call (15-20 min)

• Verify basic requirements (programming experience, motivation)
• Discuss salary expectations and work format
• Brief company and projects overview
• Goal: filter out unsuitable candidates before deep interview

Stage 2: Technical home assignment (2-4 hours to complete)

Practical Django task:

"""
Assignment: Password Manager — web password storage
 
Description:
Develop a simple Django web application for secure storage
of credentials (logins and passwords for various services).
 
Requirements:
 
1. Django application with models:
   - User (built-in Django model for authentication)
   - PasswordEntry (title, website, username, password, created_at, user)
 
2. Functionality:
   - User registration and authentication
   - CRUD operations with password entries (only own entries)
   - Password encryption before saving to DB
   - Search entries by title/website
   - Simple web interface (Django templates are fine)
 
3. Security:
   - Passwords must be stored encrypted
   - Users see only their own entries
   - Protection against SQL injection, XSS
   - User input validation and sanitization
 
4. Code:
   - PEP 8 compliance
   - Model migrations
   - Minimum 3-5 unit tests
 
5. Documentation:
   - README with setup instructions
   - Encryption approach description
   - Known limitations (if any)
 
Evaluated:
- Code quality (structure, readability, PEP 8)
- Security understanding (encryption, CSRF, XSS)
- Django knowledge (models, views, forms, auth)
- Testing (correctness and coverage)
- Git (commit messages, commit structure)
- Documentation
 
Bonus (optional):
- Django REST Framework API instead of templates
- Password strength indicator
- Export/Import functionality
- Docker for deployment
"""

Home assignment evaluation criteria:

• ✅ Security awareness: proper password encryption, protection from XSS/CSRF/SQL injection
• ✅ Code quality: PEP 8, naming, structure, separation of concerns
• ✅ Django patterns: proper use of models, views/viewsets, forms, authentication, authorization
• ✅ Testing: test coverage, test case correctness (especially security)
• ✅ Git hygiene: commit messages, logical commit structure
• ✅ Documentation: README with instructions, encryption approach explanation

Stage 3: Technical interview (60-90 min)

Structure:

1. Home assignment review (30 min)

   • Encryption: which algorithm chosen and why? Symmetric vs asymmetric?
   • Authorization: how is checking implemented that user sees only their entries?
   • Security: what threats were considered? What would you add for production?
   • Architecture: why this code structure? Alternatives?
   • Trade-offs: what would you do differently with more time?

2. Live coding session (30 min)

   • Feature extension: add "share password with another user"
   • How would you change the model? How ensure security?
   • Or: implement "secure password generator" (Python function)
   • Goal: see thinking process in real-time, approach to new requirements

3. Theoretical questions (20 min)

   • Django ORM (N+1 queries, select_related, prefetch_related)
   • HTTP/REST principles
   • Database (indexes, transactions, migrations)
   • Python basics (decorators, generators, context managers)

4. Soft skills & culture fit (10 min)

   • Team work experience
   • Code review approach
   • How do you learn new things?

Stage 4: Team meet / Final interview (30-40 min)

• Introduction to future colleagues
• Discussion of projects and technologies
• Answering candidate's questions
• Goal: assess team fit, candidate motivation

3. Candidate Evaluation Criteria

Scoring matrix for objective assessment:

Passing score:

• Junior: 50-65% (learnability more important than current knowledge)
• Middle: 70-85%

4. Onboarding and Training Program

First 2 weeks: Adaptation and basic training

Week 1: Project introduction

Day 1-2: Environment setup
- Hardware provision (laptop, access)
- Dev environment setup (Python, Django, PostgreSQL, Git)
- Internal tools access (GitLab, Redmine, Wiki)
- Team introduction
 
Day 3-5: Codebase study
- Existing project architecture
- Code walkthrough with senior developer
- Coding standards and conventions review
- Documentation and Wiki reading
 
Assignment: Fix 2-3 simple bugs (good first issues)
- Goal: learn codebase navigation, review process

Week 2: First real task

• Getting a small feature from backlog (well-scoped)
• Pair programming with mentor
• Code review and feedback on every commit
• Result: First merge to production

Month 1-3: Skill development

Weekly training sessions:

• Monday: Production complex cases review
• Wednesday: Code review session (learning to review others' code)
• Friday: Tech talk (one developer shares knowledge)

Mentorship:

• Each junior assigned a senior mentor
• Weekly 1-on-1 meetings (30 min)
• Help with technical blockers
• Career development and feedback

Practical assignments:

1. Django Deep Dive (week 3-4)

   • Building RESTful API from scratch
   • ORM optimization (N+1 problem, select_related)
   • Middleware and request lifecycle
   • Testing: fixtures, factories, mocking

2. Database & Performance (week 5-6)

   • DB schema design (normalization)
   • Indexes and query optimization
   • Django migrations best practices
   • Profiling (django-debug-toolbar, query logging)

3. Production readiness (week 7-8)

   • Deployment (Nginx, uWSGI, systemd)
   • Monitoring and logging (Sentry for errors)
   • Security (SQL injection, XSS, CSRF)
   • Caching strategies (Redis, memcached)

Knowledge base:

• Internal Wiki with guides and best practices
• Code examples and templates for common tasks
• Video recordings of technical talks
• Reading list — recommended articles and books

5. Hiring Success Metrics

Process efficiency tracking:

Conversion funnel:

Resume received → 100%
  ↓
Screening call → 40% (selecting those meeting criteria)
  ↓
Home assignment sent → 80% (interest confirmed)
  ↓
Home assignment completed → 60% (motivation filter)
  ↓
Technical interview → 70% (those who complete usually pass)
  ↓
Offer → 50% (high bar for quality)
  ↓
Offer accepted → 85% (competitive conditions)

Time to hire:

• Average: 5-7 days from first contact to offer
• Fast track: 3 days for outstanding candidates
• Goal: don't drag out process to avoid losing candidate

Quality of hire:

• Performance review at 3, 6, 12 months
• Retention rate: > 85% after one year (vs 60% industry average)
• Ramp-up time: time to full productivity — 2-3 months for junior

Results

Quantitative results:

Qualitative results:

For company:

• Scaling delivery — increased throughput for projects
• Reduced senior market dependency — growing talent internally
• Predictable hiring — reproducible process for future hires
• Reduced attrition cost — less turnover in first months

For team:

• Uniform skill level — all went through same training program
• Shared coding standards — consistent code quality
• Mentorship culture — seniors involved in junior development
• Knowledge sharing — regular tech talks and code review sessions

For candidates:

• Transparent process — clear expectations at each stage
• Fast feedback — decisions in days, not weeks
• Structured onboarding — not "thrown into water", but gradual training
• Career growth — clear path from junior to middle/senior

Key Takeaways

Junior investment pays off: In conditions of senior shortage, junior hiring and training strategy proved more effective. Cost: training time. Benefit: loyalty, culture fit, long-term growth.

Process structure > recruiter charisma: Reproducible process with clear criteria and stages gives better results than intuitive approach. Scoring matrix and home assignment reduce assessment subjectivity.

Onboarding critical for retention: First 3 months determine whether employee stays. Structured onboarding with mentorship and training sessions drastically reduces early attrition.

Technical interview as two-way street: Home assignment and live coding not only assess candidate, but also show candidate the real work. This filters out those not interested in the stack or approach.

Community building: Regular tech talks and code review sessions not only train juniors, but also strengthen team culture. Seniors get leadership experience, juniors — knowledge and mentors.

Approach applicability:

• Growing IT companies — need scalable hiring process
• Specialist shortage — grow your own talent strategy
• Tech startups — rapid team expansion
• Product companies — long-term projects where team loyalty matters

Long-term impact: Some of the hired developers grew to team leads and architects in subsequent years. This confirms the approach correctness: people investments pay off through their growth and loyalty.