Task 1 — Technical Candidate Qualification

Objective

Create a model for evaluating candidates for two technical positions:

Developer
DevOps

Both positions share common personal information, while each position also contains role-specific technical skills.

The implementation must determine whether a candidate satisfies the mandatory requirements for the selected technical position.

The result can then be used as part of the interview ranking process.

Common Candidate Information

Both Developer and DevOps candidates contain the following personal information:

First Name
Last Name
Diploma
Years of Experience

These attributes represent the common part of both technical positions.

A possible shared model is:

type Candidate struct {
    FirstName         string
    LastName          string
    Diploma           string
    YearsOfExperience int
}

The exact structure is left to the implementation.

Developer

A Developer contains the common candidate information and additional information about:

Programming Languages
Databases

A possible model is:

type Developer struct {
    Candidate Candidate
    Languages []string
    Databases []string
}

Developer Mandatory Requirements

A Developer satisfies the mandatory requirements only when all of the following conditions are true:

Years of Experience >= 5

The candidate must know:

Golang

and must know how to use both:

PostgreSQL
Mongo

Conceptually:

experience >= 5

AND

languages contains Golang

AND

databases contains PostgreSQL

AND

databases contains Mongo

Developer Example — Qualified

Developer{
    Candidate: Candidate{
        FirstName:         "Alex",
        LastName:          "Walker",
        Diploma:           "Computer Science",
        YearsOfExperience: 7,
    },
    Languages: []string{
        "Golang",
        "Python",
    },
    Databases: []string{
        "PostgreSQL",
        "Mongo",
    },
}

This candidate satisfies all mandatory Developer requirements.

Expected qualification result:

qualified

Developer Example — Not Qualified

Developer{
    Candidate: Candidate{
        FirstName:         "David",
        LastName:          "Hill",
        Diploma:           "Software Engineering",
        YearsOfExperience: 6,
    },
    Languages: []string{
        "Golang",
    },
    Databases: []string{
        "PostgreSQL",
    },
}

This candidate has enough experience and knows Golang and PostgreSQL, but does not satisfy the Mongo requirement.

Expected qualification result:

not qualified

DevOps

A DevOps candidate contains the common candidate information and a collection of additional technical skills.

A possible model is:

type DevOps struct {
    Candidate Candidate
    Skills    []string
}

DevOps Mandatory Requirements

A DevOps candidate must have at least:

5 years of experience

and must have all four required skills:

Golang
Python
AWS
Mongo

Conceptually:

experience >= 5

AND

skills contains Golang

AND

skills contains Python

AND

skills contains AWS

AND

skills contains Mongo

DevOps Example — Qualified

DevOps{
    Candidate: Candidate{
        FirstName:         "Emma",
        LastName:          "Grant",
        Diploma:           "Information Technology",
        YearsOfExperience: 8,
    },
    Skills: []string{
        "Golang",
        "Python",
        "AWS",
        "Mongo",
        "Linux",
    },
}

This candidate satisfies all mandatory DevOps requirements.

Expected qualification result:

qualified

DevOps Example — Not Qualified

DevOps{
    Candidate: Candidate{
        FirstName:         "Ben",
        LastName:          "Miller",
        Diploma:           "Computer Engineering",
        YearsOfExperience: 7,
    },
    Skills: []string{"Golang", "Python", "AWS"},
}

The candidate is missing:

Mongo

and therefore does not satisfy all mandatory requirements.

Qualification Result

Instead of returning only:

bool

the implementation may use a structured result that explains why a candidate passed or failed.

For example:

type QualificationResult struct {
    Qualified          bool
    MissingRequirements []string
}

Example:

QualificationResult{
    Qualified: false,
    MissingRequirements: []string{"Mongo"},
}

This makes the result more useful for interview evaluation because the caller can see exactly which requirements were not satisfied.

Developer Evaluation

Conceptually:

func EvaluateDeveloper(candidate Developer) QualificationResult

The function should verify:

1. years of experience
2. Golang knowledge
3. PostgreSQL knowledge
4. Mongo knowledge

Every missing mandatory requirement should be reported.

DevOps Evaluation

Conceptually:

func EvaluateDevOps(candidate DevOps) QualificationResult

The function should verify:

1. years of experience
2. Golang skill
3. Python skill
4. AWS skill
5. Mongo skill

Every missing mandatory requirement should be reported.

Multiple Missing Requirements

The evaluation should not stop after the first failed requirement.

For example:

Developer{
    Candidate: Candidate{
        YearsOfExperience: 3,
    },
    Languages: []string{"Python"},
    Databases: []string{"PostgreSQL"},
}

is missing several requirements:

minimum 5 years of experience
Golang
Mongo

A useful result would therefore contain all three failures.

Skill Matching

Skill names should be compared consistently.

The implementation should define whether values such as:

Golang
golang
Go

represent the same skill.

The original task names the required language specifically as:

Golang

so an implementation should use a deterministic representation rather than relying on uncontrolled free-form spelling.

The same applies to:

PostgreSQL
Mongo
Python
AWS

Interview Ranking

The original task states that qualification should be usable for ranking candidates during the interview process.

However, it defines only mandatory pass/fail requirements and does not define a scoring formula.

Therefore this task requires determining whether candidates satisfy mandatory requirements.

A numerical ranking system should not be invented unless it is added as an explicit extension.

Requirements

The implementation must:

1. model common personal information
2. model Developer-specific technical information
3. model DevOps-specific technical information
4. evaluate Developer mandatory requirements
5. evaluate DevOps mandatory requirements
6. report whether the candidate is qualified
7. identify missing mandatory requirements

Modeling Goal

The important part of this task is not only the final qualification check.

The implementation should avoid duplicating common candidate information between unrelated models.

Conceptually:

        Candidate
        ├── Developer-specific information
        └── DevOps-specific information

This allows shared personal data to remain consistent while role-specific technical requirements remain separate.

Optional Extension

A more extensible implementation may represent position requirements as data.

For example:

type PositionRequirements struct {
    MinimumExperience int
    RequiredLanguages []string
    RequiredDatabases []string
    RequiredSkills    []string
}

This would allow the evaluation engine to support additional technical positions without creating completely separate hard-coded validation logic.

This is an optional design extension and is not required by the original task.