As a fresh graduate in the software development field, securing an interview is often a nerve-wracking experience filled with excitement, anxiety, and the hope that you will be able to demonstrate your skills and potential. In these interviews, candidates are frequently asked a wide variety of technical questions designed to assess both their theoretical knowledge and practical expertise. However, there is one common trend in interviews that I believe is both unnecessary and counterproductive—interviewers asking fresh graduates about the SOLID principles.

For those unfamiliar, SOLID is an acronym that represents five design principles that guide object-oriented software development: Single Responsibility Principle (SRP), Open/Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP), and Dependency Inversion Principle (DIP). These principles are fundamental to writing clean, maintainable, and scalable code. However, while they are crucial for experienced software developers working on complex, large-scale systems, I believe that asking fresh graduates—who are typically still getting their feet wet in the industry—about these principles is not only unfair but also misses the point of what they should be focusing on during their early career.

In this article, I will delve into the reasons why I believe interviewers should reconsider asking fresh graduates about SOLID principles, and why there are more relevant and beneficial areas of focus when hiring entry-level software developers.   

1. Fresh Graduates Are Still Learning the Basics

One of the most glaring issues with asking fresh graduates about SOLID principles is that they are still in the process of learning the foundational concepts of programming. As recent graduates, many of us have just begun transitioning from theoretical knowledge acquired during our academic studies to applying that knowledge in a real-world environment. Fresh graduates are often more focused on learning the practicalities of programming, such as understanding how to work with version control systems like Git, writing clean and readable code, debugging issues, and learning the intricacies of a specific language or framework.

While SOLID principles are important, they assume a level of experience that most fresh graduates do not have. Understanding these principles requires practical experience in designing software that follows best practices and involves building real-world systems—something that is usually not emphasized during the early years of university education. For a fresh graduate, the core focus should be on understanding basic algorithms, data structures, problem-solving, and building familiarity with the tools and technologies they'll be using in their jobs.    

2. SOLID Principles Are Advanced Concepts

The SOLID principles are often taught later in the software development journey, typically when developers start to work on larger, more complex systems that require careful design and architectural decisions. They are extremely useful when maintaining and extending codebases, but they are not the kind of knowledge a fresh graduate is expected to have mastered. It’s not uncommon for even experienced developers to struggle with fully applying SOLID principles consistently in their work, especially in situations where trade-offs between simplicity and scalability need to be made.

Instead of focusing on these advanced concepts, interviewers should prioritize questions that gauge a fresh graduate’s understanding of basic software engineering principles and their ability to problem-solve. For example, asking questions about basic algorithms, data structures, or object-oriented programming fundamentals like inheritance and polymorphism would be far more relevant and useful. These questions assess a candidate’s ability to think logically, break down problems, and write code that functions correctly—skills that will serve them well as they transition from a student to a full-time software engineer.    

3. It Creates Unnecessary Pressure

Interviewing is already a stressful experience for fresh graduates, especially when they are applying for their first job. Many of us have limited practical experience, and we are often uncertain about what employers are looking for. When interviewers ask difficult, advanced questions such as those relating to SOLID principles, it can create an atmosphere of unnecessary pressure. This pressure can prevent candidates from demonstrating their true potential.

Fresh graduates are still developing their knowledge, and while they may have theoretical knowledge of concepts like SOLID, they may not fully understand how to apply them in real-world scenarios. By focusing on these advanced principles, interviewers risk overwhelming candidates, potentially overlooking those who are eager to learn and grow but simply don’t yet have the experience to apply SOLID principles effectively.    

4. SOLID Principles Are Not Always Practical for Small-Scale Projects

Another issue with asking about SOLID principles during interviews for fresh graduates is that these principles are more relevant to large-scale, production-grade software that involves multiple developers working on different components of a system. In contrast, fresh graduates are usually hired to work on smaller, less complex projects in the early stages of their careers. In these environments, codebases tend to be simpler, and it’s often more important to focus on speed and simplicity than to adhere strictly to SOLID principles.

For example, a junior developer might work on building a simple feature for an existing application, where the priority is ensuring that the feature works well and integrates smoothly with the rest of the system. In such cases, applying SOLID principles, while valuable in the long run, may not be the most efficient approach. There is a time and place for SOLID principles, but for fresh graduates, the focus should be on learning to deliver functional and clean code before diving into complex design principles.    

5. It Fosters a Misunderstanding of What’s Important in Junior Roles

Another important reason why asking fresh graduates about SOLID principles is problematic is that it may mislead them into thinking that adhering strictly to design patterns and principles is the most important skill for junior developers. In reality, when you’re starting out as a junior developer, the emphasis should be on learning how to write functional code that solves real-world problems, working well in teams, and learning how to integrate code with existing systems.

Junior developers are expected to follow coding standards, write tests, and contribute to the overall progress of a project, but they are not necessarily expected to design the architecture of the entire system or make high-level decisions about how the software should be structured. These tasks are more suited for senior developers who have a deeper understanding of system design, scalability, and maintainability. 

Asking junior developers about SOLID principles can create the misconception that it’s their job to focus on these things right away, when in fact their role is to gain hands-on experience and gradually learn to apply such principles over time. The priority at the start of a developer’s career should be on improving coding practices, debugging skills, and learning to work with other team members, not mastering architectural patterns.     

6. A Better Focus: Problem-Solving and Communication Skills

Instead of grilling fresh graduates about SOLID principles, interviewers should focus on questions that gauge a candidate’s ability to solve problems, think critically, and work well with others. Problem-solving is the backbone of software development, and it’s the skill that fresh graduates should be developing and showcasing during their interviews.

Furthermore, good communication skills are essential for working in teams and collaborating on projects. Developers need to be able to explain their ideas clearly, ask questions when they are unsure, and listen to feedback. Therefore, interviews should place more emphasis on testing how well candidates can approach and solve problems logically, as well as how they articulate their thought process.    

7. What Fresh Graduates Should Focus on in Interviews 

While the SOLID principles are undoubtedly valuable, fresh graduates should focus on the following areas during interviews:

- Basic Programming Knowledge: Understanding algorithms, data structures, and problem-solving. 

- Language Proficiency: Comfortably writing code in a specific language, such as Python, Java, or JavaScript. 

- Understanding of Object-Oriented Programming: Grasping the basics of classes, objects, inheritance, and polymorphism. 

- Version Control: Familiarity with tools like Git to manage code repositories.

- Communication Skills: Explaining your thought process clearly and asking relevant questions.  

While SOLID principles are important for building scalable, maintainable software systems, they are not something fresh graduates should be expected to master. The reality is that many junior developers are still learning how to work with the tools and frameworks of their chosen programming languages. By asking fresh graduates about advanced concepts like SOLID, interviewers risk making them feel unprepared, pressured, and misled about what is expected of them in their first software development role.

Instead, interviewers should focus on testing the candidate’s fundamental programming skills, problem-solving abilities, and willingness to learn. Fresh graduates are at the beginning of their career journey, and while they should be aware of SOLID principles, the focus of an interview should be on their potential, enthusiasm, and ability to grow into a valuable member of the team. It is only over time, with experience and mentorship, that they will truly begin to appreciate and apply SOLID principles effectively.