At Zarego, hiring the right talent involves more than just reviewing resumes and conducting interviews. What Zarego Looks For When Hiring, several key factors play a crucial role in our hiring process: academic excellence, proficiency in English, cultural fit, and a collaborative mindset among others. However, to ensure that the new members joining our team are technically proficient, we rely on the tried-and-true method of the “coding challenge.”
The Old Way (and why it doesn’t work)
In the early days of software development, hiring engineers often involved just an interview, where the candidate was assessed based on their spoken answers alone. This method, however, had its flaws. Many companies experienced the unfortunate scenario where a candidate with an impressive resume would show up on their first day with a book like “PHP for Dummies”, revealing a significant gap between their claimed and actual knowledge.
The New Way: What is a Coding Challenge?
At Zarego, we validate candidates’ technical skills by working together on a brief project. These projects are not extensive in scope, but they are designed to give us a clear understanding of how well we can collaborate. The goal is to determine if the candidate and the company are a good fit for each other. In different environments, the same developer can either thrive or struggle, so it’s important to measure various aspects like communication skills, ability to estimate time, delivery style, and most importantly, the quality of their code.
What Makes Good Code?
When reviewing code, we consider several key factors:
Documentation: Good code should be well-documented. This includes a README file that provides the next developer enough context to run, compile, and understand the project.
Avoidance of Code Duplication: Repeated chunks of code indicate that the programmer did not take the time to refactor and optimize their code.
Architectural Design: Proper architectural design is crucial. The solution should not be crammed into a single file but should demonstrate good abstraction and separation of layers.
Object-Oriented Principles: Code should respect object-oriented principles like encapsulation and polymorphism. Avoiding unnecessary inheritance in favor of composition (HAS-A vs IS-A relationships) is a good practice.
Scalability: The solution should be scalable. This includes choosing appropriate components and designing systems that can grow with increased demand.
What We Expect in Delivery
One of the most critical aspects of our assessment is the delivery phase. Here are some of the things we consider:
Timeliness: Did the candidate deliver the project within the timeframe they themselves set? Meeting deadlines is crucial in a professional setting.
Specification Adherence: Did the candidate meet the provided specifications? Adhering to requirements is a basic yet essential skill.
Added Value: Did the candidate go beyond the given tasks to add value, suggest improvements, or propose new ideas in their documentation?
Best Practices: Does the code follow established best practices? Familiarity with foundational books like Uncle Bob’s “Clean Code” is often reflected in the quality of their work.
Version Control: Did the candidate use Git effectively? This includes creating pull requests, making meaningful commits, and using a branching strategy like Gitflow.
Unit Testing: Did the candidate include unit tests? What percentage of the code is covered by these tests? Comprehensive testing is a hallmark of robust software development.
Library Usage: Did the candidate use libraries correctly and as expected? Proper usage of third-party libraries can greatly enhance a project’s functionality and maintainability.
A Great Team is Something You Build Every Day
Finding programmers who can meet the high standards of quality that we at Zarego pride ourselves on providing to our clients is no easy task. A lot of people are drawn to the tech industry but lack the necessary skills or experience for the positions they apply for. It is crucial to identify these gaps early on to ensure that each team member is placed appropriately. You don’t want to put a junior developer in a senior role or a mid-level developer in an architect’s position; such mismatches are recipes for disaster.
At Zarego, we have developers of all senioritis who grow and learn from each other through collaborative pull requests, our internal programming seminars, and the spontaneous, enriching discussions that take place in our break room over a cup of coffee. This collaborative environment ensures that our team members continuously develop their skills and stay updated with the latest industry practices.
By maintaining a rigorous hiring process that includes a coding challenge, we ensure that we bring onboard individuals who are not only technically proficient but also a good fit for our team’s culture and work style. This approach has helped us build a strong, cohesive team capable of delivering high-quality solutions to our clients.