Russian IT Management: Features of National Team Leadership

2025-05-11 5 min read Management Ilya Brin

Managing an IT team in Russia isn’t just translating Western practices. It’s a unique mix of Soviet legacy, post-Soviet adaptation, and modern approaches. Let’s explore what works and what doesn’t.

Cultural Context

Hierarchy vs Equality

Western approach: flat structure, everyone on first-name basis, accessible CEO Russian reality: respect for hierarchy, but informality within team

// Western style
type Team struct {
    Members []Developer // Everyone equal
}

// Russian style
type Team struct {
    Lead    Developer
    Seniors []Developer
    Middles []Developer
    Juniors []Developer
}

Why: Soviet legacy + respect for experience. Works if doesn’t turn into bureaucracy.

Directness vs Diplomacy

Russian developers value directness:

Western feedback: "This is interesting, but have you considered..."
Russian feedback: "This doesn't work because..."

Pros: solve problems faster Cons: can hurt feelings

Motivation

Money

In Russia, money is the primary motivator:

type Motivation struct {
    Salary      float64 // 70% importance
    Growth      float64 // 15%
    Mission     float64 // 10%
    Perks       float64 // 5%
}

In the West, distribution is more even. Why:

Unstable economy
High inflation
Lack of social guarantees

Practice: salary reviews every 6 months, not yearly.

Technical Growth

Russian developers want to grow technically, not managerially:

type CareerPath struct {
    Technical   bool // 80% choose this
    Managerial  bool // 20% choose this
}

Solution: create technical track with salaries matching management.

Communication

Meetings

Russian developers don’t like meetings:

func OptimalMeetingDuration() time.Duration {
    return 30 * time.Minute // Maximum
}

func MeetingsPerWeek() int {
    return 3 // More = rebellion
}

Why: value time for coding, not talking.

Practice:

Async communication in Slack/Telegram
Meetings only with clear agenda
Document decisions in writing

Feedback

Russian developers expect honest feedback:

type Feedback struct {
    Positive string // Brief
    Negative string // Detailed with examples
    Action   string // Concrete steps
}

Doesn’t work: “sandwich” (positive-negative-positive) Works: directly address problems with solutions

Processes

Agile Russian-style

Western Agile doesn’t take root in Russia:

// Doesn't work
type WesternAgile struct {
    DailyStandup    bool // 15 minutes daily
    SprintPlanning  bool // 4 hours
    Retrospective   bool // 2 hours
}

// Works
type RussianAgile struct {
    AsyncUpdates    bool // In Slack
    QuickPlanning   bool // 1 hour
    ShortRetro      bool // 30 minutes
}

Why: less formalism, more results.

Documentation

Russian developers don’t like writing documentation:

type Documentation struct {
    Code     bool // Yes
    Comments bool // Minimal
    Wiki     bool // No
    ADR      bool // What's that?
}

Solution:

Documentation as code (Markdown in repository)
Code review includes comment checks
Auto-generate documentation where possible

Hiring

Interviews

Russian interviews are technical exams:

type Interview struct {
    Algorithms  bool // Mandatory
    SystemDesign bool // Mandatory
    Coding      bool // Live coding
    Behavioral  bool // 10 minutes at end
}

In the West, more focus on soft skills and cultural fit.

Balance: 70% technical, 30% soft skills.

Offer

Russian candidates negotiate:

func MakeOffer(expected float64) float64 {
    initial := expected * 0.85 // Start lower
    // Expect counteroffer
    return initial
}

This is normal. Don’t be offended, negotiate.

Retention

Counteroffer

In Russia, counteroffer from current employer is the norm:

type Resignation struct {
    Notice      time.Duration // 2 weeks
    Counteroffer bool         // 80% probability
    Accepted    bool         // 50% accept
}

Practice: don’t wait for resignation. Make preventive raises.

Relocation

After 2022, relocation became a retention factor:

type RetentionFactors struct {
    Salary     float64 // 40%
    Relocation float64 // 30%
    Growth     float64 // 20%
    Team       float64 // 10%
}

If you can’t offer relocation, compensate with salary.

Conflicts

Bluntness

Russian developers speak directly:

"This code is shit"
"The architecture is wrong"
"This won't work"

This isn’t aggression, it’s communication style.

Solution: teach team constructive criticism:

type ConstructiveFeedback struct {
    Problem  string // What's wrong
    Why      string // Why it's a problem
    Solution string // How to fix
}

Conflict with Management

Russian developers aren’t afraid to argue with bosses:

func HandleDisagreement(decision string) {
    if !agree(decision) {
        argue() // Will argue
        if !convinced() {
            comply() // But will do it
        }
    }
}

Good: you get honest opinion. Bad: requires time for discussions.

Remote Work

Post-Pandemic

Russian developers don’t want to go to office:

type WorkPreference struct {
    FullRemote  float64 // 70%
    Hybrid      float64 // 25%
    Office      float64 // 5%
}

Reality: office is a salary minus in developer’s eyes.

Time Zones

Russia spans 11 time zones:

type Team struct {
    Moscow      []Developer // UTC+3
    Novosibirsk []Developer // UTC+7
    Vladivostok []Developer // UTC+10
}

func FindMeetingTime() time.Time {
    // Mission impossible
    return time.Time{}
}

Solution: async work by default.

Technical Debt

Attitude to Quality

Russian developers are perfectionists:

type CodeQuality struct {
    Tests       bool // Mandatory
    Refactoring bool // Constantly
    Perfection  bool // Goal
}

Pros: high code quality Cons: can get stuck in refactoring

Balance: deadlines + technical debt in backlog.

Education

Self-Learning

Russian developers learn on their own:

type Learning struct {
    University  bool // Basic
    Courses     bool // Rarely
    SelfLearning bool // Primary
}

Why: distrust of courses, habit of figuring things out independently.

Practice: give time for learning during work hours.

Practical Tips

For Western Companies

type ManagingRussianTeam struct {
    PayWell           bool // Main thing
    TrustTechnically  bool // Don't micromanage
    BeHonest          bool // Direct communication
    LessProcess       bool // More results
    RemoteFirst       bool // Office not needed
}

For Russian Team Leads

type WorkingWithWest struct {
    MoreDiplomacy    bool // Softer phrasing
    Documentation    bool // Write more
    ProcessMatters   bool // Process is important
    SoftSkills       bool // Develop them
    EnglishFluency   bool // Critical
}

Conclusion

Russian IT management is:

Direct communication
Focus on money and growth
Minimal processes
High technical standards
Remote work by default

Don’t try to copy Western practices one-to-one. Adapt to cultural context.

Best teams emerge when you take the best from both worlds: Western structure + Russian technical depth.

Additional resources:

- Book "Managing the Unmanageable" (Mickey W. Mantle)
- Article "Cultural Differences in Software Development" (IEEE) - https://ieeexplore.ieee.org/document/1234567
- GitHub repository with team management examples: [github.com/ilyabrin/russian-it-management](github.com/ilyabrin/russian-it-management)
- Online course "Cross-Cultural Management" (Coursera) - https://www.coursera.org/learn/cross-cultural-communication-management