UST | Senior .NET Developer | Remote | Jan 14, 2025 [Reject]

Status:

Experienced professional with 3.8 years of backend development experience, previously worked with .NET, Golang, and Java. Currently exploring new opportunities after resigning from my current organisation.

Position:

Senior .NET Developer

Location:

Remote

Date:

January 14, 2025

Interview Process and Format

Round 1: Technical Phone Screen (1 Hour)

1. Behavioral Questions:

   • The interviewer started by asking about my professional background, projects, and responsibilities in previous roles.
   • Questions on my reasons for transitioning and expectations for the new role were also discussed.

2. Technical Questions:

   • OOP Concepts:
     I was given a program to predict its output, which tested understanding of inheritance and polymorphism.

     using System;
     
     namespace OOPTest
     {
         class Parent
         {
             public virtual void Display()
             {
                 Console.WriteLine("Parent class method.");
             }
         }
     
         class Child : Parent
         {
             public override void Display()
             {
                 Console.WriteLine("Child class method.");
             }
         }
     
         class Program
         {
             static void Main(string[] args)
             {
                 Parent obj1 = new Parent();
                 Parent obj2 = new Child();
                 Child obj3 = new Child();
     
                 obj1.Display();
                 obj2.Display();
                 obj3.Display();
             }
         }
     }

     My Response: I correctly explained the output:

     Parent class method.
     Child class method.
     Child class method.

   • Microservices Deployment in .NET Core:
     Microservices in .NET Core are containerized using Docker, deployed to cloud platforms (e.g., AWS, Azure, Kubernetes), and orchestrated using CI/CD pipelines for scalability and maintenance.

   • SOLID Design Principles:
     I explained the five principles of object-oriented design:

     1. Single Responsibility Principle
     2. Open/Closed Principle
     3. Liskov Substitution Principle
     4. Interface Segregation Principle
     5. Dependency Inversion Principle

   • Extension Methods in C#:
     Extension methods allow adding new methods to existing types without modifying them. The this keyword is used in the first parameter to define them.

   • Abstract vs. Virtual Methods:
     Abstract methods have no implementation and must be overridden in derived classes, while virtual methods can have an implementation but can also be overridden.

   • Middlewares in .NET Core:
     Middlewares are components in the HTTP request pipeline that process requests and responses (e.g., authentication, logging).

   • Difference Between app.Use and app.Run:
     app.Use allows chaining multiple middlewares, while app.Run defines a terminal middleware and ends the pipeline.

   • Conditional Middleware Execution:
     Middleware can be executed conditionally using app.UseWhen.

   • Entity Framework Questions:

     • First vs. FirstOrDefault:
       First throws an exception if no element is found, while FirstOrDefault returns null or the default value.
     • INNER JOIN vs. OUTER JOIN:
       INNER JOIN returns only matching rows, while OUTER JOIN includes unmatched rows with NULL values.
     • LEFT JOIN vs. OUTER JOIN:
       LEFT JOIN is a type of OUTER JOIN that returns all rows from the left table and matching rows from the right, with NULL for non-matching rows.

   • Dependency Injection in .NET Core:
     Dependency Injection is built-in, with services registered as Transient, Scoped, or Singleton and injected via constructors.

3. Feedback:
   The interviewer mentioned that while I demonstrated strong fundamentals and practical knowledge, I needed to deepen my understanding of advanced design patterns and microservices architecture to meet senior-level expectations.

Result:

Rejected after the first round.

My Thoughts:

The interview was engaging and thorough, focusing on both theoretical and practical aspects. Although the rejection was disappointing, the feedback was constructive and highlighted areas for improvement, particularly around design patterns and scalability practices for microservices.