SDET Interview Questions And Answers (Complete Guide)

Read this complete guide to Software Development Engineers in Test Interviews to learn the format and how to answer the SDET Interview Questions asked in the various rounds:

In this tutorial, we will learn about some commonly asked interview questions for the SDET roles. We will also see, in general, the common pattern of the interviews and share some tips to excel in the interviews.

Even though we will be using Java language for the coding problems for this tutorial, most of the SDET tutorials are language agnostic and interviewers are generally flexible about the language that the candidate chooses to use.

SDET Interview Questions and Answers

SDET Interview Preparation Guide

SDET interviews, in most of the top product companies, are quite similar to the way interviews are conducted for development roles. This is because SDETs are also expected to know and understand broadly almost everything that the developer knows.

What differs is the criteria on which the SDET interviewee is judged. Interviewers for this role look for critical thinking skills, as well as whether the person being interviewed has hands-on experience in coding and has an eye for quality and detail.

Here are some points that someone preparing for an SDET interview should largely focus on:

• Since, most of the time, these interviews are technology/language agnostic, hence candidates must be willing to learn new technology (and leverage existing skills) as and when required.
• Should have good communication and team skills as SDET roles these days require communication and collaboration at various levels with multiple stakeholders.
• Should have a basic understanding of different system design concepts, scalability, concurrency, non-functional requirements, etc.

In the sections below, we will try to understand the general format of the Interview along with some sample questions.

Software Development Engineer Test Interview Format

Most companies have their preferred format of interviewing candidates for an SDET role as at times, the role is super specific to the team and the person is expected to be evaluated as a perfect fit for the team the person is being hired for.

However, the theme of the interviews is generally based around the following points:

• Telephonic discussion: Conversation with the manager and/or team members which is usually a screening round.
• Written round: With testing/test casing specific questions.
• Coding proficiency round: Simple coding questions (language agnostic) and the candidate is asked to write production-level code.
• Understanding basic development concepts: Like OOPS Concepts, SOLID Principles, etc.
• Test Automation Framework design and development
• Scripting languages: Selenium, Python, Javascript, etc
• Cultural Fit/HR discussion and negotiations

SDET Interview Questions and Answers

In this section, we will discuss some sample questions along with detailed answers, for different categories that are asked by most product companies hiring for SDET roles.

Coding Proficiency Test

In this round, simple coding problems are given to write in the language of choice. Here, the interviewer wants to gauge the proficiency with coding constructs as well as handle things like edge scenarios and null checks, etc.

Occasionally, interviewers might also ask to write down unit tests for the program written.

Let’s see some sample problems.

Q #1) Write a program to swap 2 numbers without using the 3rd (temporary) variable?

Answer:

Program to swap two numbers:

public class SwapNos {

  public static void main(String[] args) {
    System.out.println("Calling swap function with inputs 2 & 3");
    swap(2,3);
    System.out.println("Calling swap function with inputs -3 & 5");
    swap(-3,5);
  }
  
  private static void swap(int x, int y) {
    System.out.println("values before swap:" + x + " and " + y);
    // swap logic
    x = x + y;
    y = x - y;
    x = x - y;
    System.out.println("values after swap:" + x + " and " + y);
  }
}

Here’s the output of the above code snippet:

In the above code snippet, it is important to note that, the interviewer has specifically asked to swap 2 nos without using a third temporary variable. Also, it’s important that before submitting the solution, it’s always recommended to go through (or dry run) the code for at least 2-to 3 inputs. Let’s try for positive and negative values.

Positive values: X = 2, Y = 3

 // swap logic - x=2, y=3
x = x + y; => x=5
y = x - y; => y=2
x = x - y; => x=3 
x & y swapped (x=3, y=2)

Negative values: X= -3, Y= 5

// swap logic - x=-3, y=5
x = x + y; => x=2
y = x - y; => y=-3
x = x - y; => x=5
x & y swapped (x=5 & y=-3)

Q #2) Write a program to reverse a number?

Answer: Now the problem statement might initially look intimidating, but it’s always wise to ask clarifying questions (but not a lot of details). Interviewers can choose to provide hints about the problem, but if the candidate asks a lot of questions, then it also points to the candidate not being given enough time to understand the problem well.

Here, the problem expects a candidate to make some assumptions as well – for example, the number could be an integer. If the input is 345 then the output should be 543 (which is the reverse of 345)

Please see the code snippet for this solution:

public class ReverseNumber {
  public static void main(String[] args) {
    int num = 10025;
    System.out.println("Input - " + num + " Output:" + 
reverseNo(num));
  }  

public static int reverseNo(int number) {
    int reversed = 0;    
    
     while(number != 0) {
          int digit = number % 10;
          reversed = reversed * 10 + digit;
          number /= 10;
    }
    return  reversed;
  }
}

The output for this program against input: 10025 – Expected would be: 52001

Q #3) Write a program to calculate the factorial of a number?

Answer: Factorial is one of the most commonly asked questions in almost all interviews (including the developer interviews)
For developer interviews, more focus is on programming concepts like dynamic programming, recursion, etc., whereas from the Software Development Engineer in Test perspective, it’s important to handle the edge scenarios like max values, min values, negative values, etc. and approach/efficiency are important but become secondary.

Let’s see a program for factorial use recursion and for-loop by handling negative numbers and returning a fixed value of say -9999 for negative numbers which should be handled in the program calling the factorial function.
Please refer to the code snippet below:

public class Factorial {

  public static void main(String[] args) {

    System.out.println("Factorial of 5 using loop is:" + factorialWithLoop(5));
    System.out.println("Factorial of 10 using recursion is:" + factorialWithRecursion(10));
    System.out.println("Factorial of negative number -100 is:" + factorialWithLoop(-100));

  }

  public static long factorialWithLoop(int n) {
    if(n < 0) {
      System.out.println("Negative nos can't have factorial");
      return -9999;
    }
    long fact = 1;
    for (int i = 2; i <= n; i++) {
      fact = fact * i;
    }
    return fact;
  }

  public static long factorialWithRecursion(int n) {
    if(n < 0) {
      System.out.println("Negative nos can't have factorial");
      return -9999;
    }

    if (n <= 2) {
      return n;
    }
    return n * factorialWithRecursion(n - 1);
  }

}

Let’s see output for – factorial using the loop, factorial using recursion, and factorial of a negative number (which would return a default set value of -9999)

Q #4) Write a program to check whether a given string has balanced parentheses?

Answer:

Approach – This is a slightly complex problem, where the interviewer is looking slightly more than knowledge of just coding constructs. Here, the expectation is to think and use the apt data structure for the problem at hand.

A lot of you might feel intimidated by these types of problems, as some of you might not have heard these, and therefore even if they are simple, they may sound complex.

But generally for such problems/questions:  For example, in the current question, if you don’t know what balanced parentheses are, you can very well ask the interviewer and then work towards the solution instead of hitting a blind spot.

Let’s see how to approach a solution: After understanding what balanced parentheses are, you can think about using the right data structure and then start writing algorithms (steps) before you start coding the solution. A lot of times, the algorithms themselves solve a lot of edge scenarios and give a lot of clarity on what the solution will look like.

Here’s a look at the solution:

Balanced parentheses are to be checked for a given string that contains parentheses (or brackets) and should have equal opening and closing count as well as positionally well structured. For the context of this problem, we will use balanced parentheses such as – ‘()’, ‘[]’, ‘{}’ – i.e given string can have any combination of these brackets.

Please note that before attempting the problem, it’s good to clarify if the string will just contain bracket characters or any numbers, etc (as this might change the logic a bit)

For example: A given string – ‘{ [ ] {} ()} – is a balanced string as it’s structured and has equal no of closing and opening parentheses, but string – ‘{ [ } ] {} ()’ – this string – even though it has equal to no of opening and closing parentheses, this is still not balanced because we can see that without a closing ‘[‘ we’ve closed ‘}’ (i.e. all inner brackets should be closed before closing the outer bracket)

We will be using a stacked data structure to solve this problem.

A stack is a LIFO (Last In First Out type of data structure), think of it as a stack/pile of plates at a wedding – you will pick up the topmost plate whenever you are using it.

Algorithm:

#1) Declare a Character Stack (which would hold the characters in the string and depend on some logic, push and pop the characters out).

#2) Traverse through the input string, and whenever

• There’s an opening bracket character – i.e. ‘[‘, {‘ or ‘(‘ – push the character on Stack.
• There’s a closing character – i.e. ‘]’, ‘}’, ‘)’ – pop an element from Stack and check if it matches the opposite of the closing character – i.e. if the character is ‘}’ then on Stack pop you should expect ‘{‘
  • If the popped element does not match the closing parentheses, then the string is not balanced and you can return results.
  • Else continue with the stack push and pop approach (go to step 2).
• If the string is traversed completely and the Stack size is zero as well, then we can say/infer that the given string is a balanced parentheses string.

At this point, you might also want to discuss the solution approach you have as an algorithm and ensure that the interviewer is ok with the approach.

Code:

import java.util.Stack;

public class BalancedParanthesis {

  public static void main(String[] args) {

    final String input1 = "{()}";
    System.out.println("Checking balanced paranthesis for input:" + input1);

    if (isBalanced(input1)) {
      System.out.println("Given String is balanced");
    } else {
      System.out.println("Given String is not balanced");
    }
  }

  /**
   * function to check if a string has balanced parentheses or not
   * @param input_string the input string
   * @return if the string has balanced parentheses or not
   */
  private static boolean isBalanced(String input_string) {

    Stack<Character> stack = new Stack<>();

    for (int i = 0; i < input_string.length(); i++) {

      switch (input_string.charAt(i)) {
        case '[':
        case '(':
        case '{':
          stack.push(input_string.charAt(i));
          break;
        case ']':
          if (stack.empty() || !stack.pop().equals('[')) {
            return false;
          }
          break;
        case '}':
          if (stack.empty() || !stack.pop().equals('{')) {
            return false;
          }
          break;
        case ')':
          if (stack.empty() || !stack.pop().equals('(')) {
            return false;
          }
          break;
      }
    }
    return stack.empty();
  }
}

Here is the output of the above code snippet:

Like we did for our previous coding problems, it’s always good to dry run the code with at least 1-2 valid as well as 1-2 invalid inputs and ensure that all cases are appropriately handled.

NOTE: It’s always good to think out the solution out loud (and not just within the mind) – and surprisingly this is an important trait that interviewers are looking for. A lot of interviewers could just do away with the algorithm and move to the next problem statement.

In the above coding solution, for the developer interview, the interviewer might ask to solve it using arrays instead of direct stack (i.e. using array as a stack), but in general, it’s more about being conceptually clear and able to handle all valid and invalid inputs.

Test Automation Framework Related Questions

This section of the interview is more specific to testing and SDET responsibilities. Expect automation framework design and development-related questions, pros and cons of using different approaches, etc.

Please see sample questions and solutions for the same.

Q #5) Explain and design components of the automation framework for a web application?

Answer: This question is a little subjective, and the interviewer intends to gauge how much the candidate knows about the framework design and development. The answer to this question helps the interviewer understand if the candidate can build or create custom frameworks from scratch.
Let’s see a couple of points that would help you structure the solution for this question:

• You can talk about different types of frameworks like – Data-driven, Keyword-driven, Hybrid Framework.
• Page Object Model for storing details of various elements on different pages/modules of the web application.
• Common modules such as helper functions, utilities, loggers, etc.
• Reporting modules like generating reports for test execution, integrating reports with email, scheduling test execution, etc.

Recommended Reading=> Most Popular Test Automation Frameworks

Q #6) Explain testing strategies for a mobile application?

Answer: These questions are typically asked depending on the role. If the role is majorly to work on mobile apps then the question holds more relevance. We can talk based on your experience if you have planned mobile testing as part of your current or previous roles.

Some pointers to structure the answer to this question could be,

• Testing on devices vs emulators.
• Identifying and storing objects/elements on different screens – Example: Page Object Model.
• Load testing on a mobile application.
• You can talk about different types of mobile applications like – Native apps, Hybrid apps, and discuss strategies/approaches you would use to test them.

Recommended Reading=> Mobile App Testing Tutorials

Q #7) Design an Automation framework for testing REST APIs?

Answer: This is again a subjective question and you can ask clarifying questions whether the interviewer wants you to develop a framework for testing functional behavior of API or non-functional requirements like Load/Performance testing.

You can start your answer by covering the following points:

• API Automation framework components like Local setup, Mock setup of API, or Hosted API Testing.
• Tools used for API Automation. There are various tools available out of the box to validate the functional aspects of a REST-based API. Some such tools are Postman, Rest Assured, etc. For in-depth details about the different tools, you can refer to our article here.
• Non Functional Automation of the APIs.
• Scheduled Execution of automation tests.
• Integrating automation tests for APIs.

Q #8) Framework specific questions.

Answer: At times depending on the profile being interviewed, there might be a requirement for a candidate to be proficient with a certain framework – ex. Selenium, JMeter, etc.

Recommended Reading=> Postman, Mockito, Specflow, Selenium, JMeter

Testing Related Questions

Although rarely, depending upon the profile, there might be questions around general testing practices, terms & technologies – like bug severity, priority, test planning, test casing, etc. An SDET is expected to know all manual testing concepts and should be familiar with the important terminologies.

In this section, you can expect questions like these:

Q #9) What are the different components of a test plan?

Answer: These are generally asked to validate basic testing concepts and mindsets. These terms and documents are something that every manual QA, as well as automation SDETs, should know.
You can discuss various components of the test plan here like,

• Entry and Exit Criteria
• Scope: Discuss the test features that are in scope and what would all be automated – Will it just be functional features or non-functional requirements like scalability, performance, etc.
• Timelines
• Tools to be used
• Resource allocation, etc

Recommended Reading=> How to write a good test plan

Q #10) What defines and decides a bug’s priority and severity?

Answer: Defect Priority and Severity can easily be explained with the help of examples. Suppose a feature like sign-up is broken and is preventing users from accessing the application – then it’s a high priority and high severity issue. Similarly, there can be examples of Low Severity/High Priority defects and various other combinations.

In general,

• Priority signifies the importance of the issue.
• Severity signifies the impact that the issue is having on the customer or user of the application.

Recommended Reading=> Defect Priority and Severity

Q #11) What is Equivalence Partitioning? Illustrate with an example.

Answer: Equivalence Partitioning is a technique mostly used for black box testing, to test various combinations of inputs against a given field.

For example, if you are testing a trading application, and you want to write all the test scenarios for the “Quantity” field – what would be the different inputs you would be testing for this field?
Given the functional requirement is quantity should be a positive integer value between 1 and 100000. So to test various inputs (both valid and invalid), you can have tests for 1 input from each such category.

• Valid values: Between 1 and 100000 -> test for any valid value x such that x>1 and x<100000.
• Boundary values: Test for the allowed boundary values i.e. 1 & 100000.
• Invalid values: Values that lie outside of the allowed range – i.e. test for one such value for x, such that x < 1 and x > 100000.

Recommended Reading=> Equivalence Partitioning strategy

System Design Related Questions

System design questions are typically more suited for developer interviews where a developer is judged on a broad understanding of different general concepts – like scalability, availability, fault tolerance, database selection, threading, etc. In a nutshell, you will need to use your entire experience and systems knowledge to answer such questions.

But you might be feeling that a system that takes years of experience and hundreds of developers to code, how could a person answer the question in around 45 mins?

The answer is:  Here the expectation is to judge the candidate’s understanding and the broad spectrum of knowledge that he or she can apply while solving complex problems.

Currently, these questions are starting to be thrown in for SDET interviews as well. Here the expectation remains the same as that of the developer interview, but with relaxed judgement criteria, and its mostly a bar raiser round where, depending on the candidate’s answer, a candidate may be considered for the next level or moved to a lower level.

In general, for system design interview questions, the candidate should be familiar with the below concepts

1. Basics of operating systems: Paging, file systems, virtual memory, physical memory, etc.
2. Networking concepts: HTTP communication, TCP/IP stack, network topologies.
3. Scalability concepts: Horizontal and Vertical Scaling.
4. Concurrency / Threading concepts
5. Database types: SQL/No SQL databases, when to use what type of database, advantages, and disadvantages of different types of databases.
6. Hashing techniques
7. Basic understanding of CAP theorem, sharding, partitioning, etc.

Please see some sample questions

Q #12) Design a URL shortening system like a tiny URL?

Answer: Many candidates might not even know about URL shortening systems in general. In that case, it’s ok to ask the interviewer about the problem statement instead of diving down without understanding.

Before even answering such questions, candidates should structure the solution and write bullet points and then start discussing the solution with the interviewer.

Let’s discuss the solution in brief

a) Clarify functional and nonfunctional requirements

Functional requirements: Functional requirements are just simply from a customer’s perspective, it’s a system that is fed a big (long length) URL, and the output should be a shortened URL.

Once the shortened URL is accessed, it should redirect the user to the original URL. For example – try shortening the actual URL at https://tinyurl.com/ web page, feed an input URL like  www.softwaretestinghelp.com and you should get a tiny URL like https://tinyurl.com/shclcqa

Non-functional requirements: The system should be performant in terms of redirecting with millisecond latency (as its an additional hop for a user accessing the original URL).

• Shortened URLs should have a configurable expiry time.
• Shortened URLs should not be predictable.

b) Capacity/Traffic Estimation

This is very important from the perspective of all the system design questions. Capacity Estimation is essentially determining the expected load that the system is going to get. It’s always good to start with an assumption, and discuss it with the interviewer. This is also important from the perspective of planning the database sizing, whether the system is read-heavy or write-heavy etc.

Let’s do some capacity numbers for the URL shortener example.

Suppose there will be 100k new URL shortening requests per day (with 100:1 read-write ratio – i.e. for every 1 shortened URL, we will have 100 read requests against the shortened URL)

We will have,

100k write requests/day => 100000/(24x60x60) => 1.15 request/second
10000k read requests/day => 10000000/(24x60x60) => 1157 requests/second

c) Storage & Memory considerations

After the capacity numbers, we can extrapolate these numbers to get,

• The storage capacity that would be required to accommodate the expected load, For example, we can plan to design a storage solution to support the requests for up to 1 year.
  Example: If every shortened URL consumes 50 bytes, then the total data/storage that we would require over a year would be:

=> total write requests/day x 365 x 50 / (1024x1024) => 1740 MB

• Memory considerations are important to plan the system from the reader’s perspective. i.e. for systems that are read-heavy – like the one we are trying to build (because the URL will be created once but accessed multiple times).
  Read-heavy systems generally use caching to become more performant and avoid reading from permanent storage to save on reading I/O.

Let’s assume we want to store 60% of our read requests in the cache, so over the year we will be requiring 60% of total reads over year x bytes required by each entry

=> (60/100) x 100000 x 365 x (50/1024x1024) => 1045 MB ~ 1GB

As per our capacity numbers, this system would require about 1 GB of physical memory

d) Bandwidth Estimations

Bandwidth estimates are required to analyze the read and write speed in bytes that would be required for a system to be performed. Let’s do estimations against the capacity numbers we have taken.

Example: If every shortened URL consumes 50 bytes, then the total read and write speeds that we would need would be as below:

WRITE - 1.15 x 50bytes = 57.5 bytes/s
READS - 1157 x 50bytes = 57500 bytes/s => 57500 / 1024 => 56.15 Kb/s

e) System design and Algorithm
This is essentially the main business logic or algorithm that would be used to fulfill the functional requirements. In this case, we want to generate unique shortened URLs for a given URL.

The different approaches that could be used to generate shortened URLs are:

Hashing: We can think of generating shortened URLs by creating a hash of the input URL and assigning the hash key as the shortened URL.

This approach might have some issues when there are different users of the service, and if they enter the same URL then they would result in getting the same shortened URL.

Pre-created shortened strings and assigned to URLs when the service is called: Another approach can be to return a predefined shortened string from the pool of already generated strings.

Service APIs: We can think of the URL shortener system as a set of REST-based APIs which have the following endpoints:

• CreateUrl (String Url, DateTime expiryTime): This endpoint creates and returns a shortened URL with expiry duration set as specified in the input.
• retrieveUrl (String shortenedUrl): This endpoint retrieves URL to be redirected against the given shortened URL.

f) Scaling and Concurrency

Scaling is an important consideration from a non-functional requirement perspective.

It deals with, how can system

• Scale under load: The system should be able to gracefully scale under load and not just stop working after an unexpected spike in load occurs.

Recommended Reading=> Scaling Techniques

• How performant can the system be, for example: if the system is used with sustained capacity for a long time, would the system performance degrade or it remains stable?

There can be a lot of different system design questions like below, but generally speaking, all of these would test candidates’ broader understanding of different concepts which we have discussed in the solution of the URL shortening system.

Q #13) Design a video platform like YouTube.

Answer: This question can also be approached, in a similar way as we have discussed the TinyUrl question above (and this applies to almost all the system design interview questions). The one differentiating factor would be to look/detail around the system you want to design.

So for YouTube, we all know it’s a video streaming application and has a lot of capabilities like allowing a user to upload new videos, stream live webcasts, etc. So while designing the system you should apply the required System design components. In this case, we might need to add components related to video streaming capabilities.

You can discuss points like,

• Storage: What kind of database would you choose to store video content, user profiles, playlists, etc?
• Security & Authentication / Authorization
• Caching: Since a streaming platform like YouTube should be performant, caching is an important factor for designing any such system.
• Concurrency: How many users can stream video in parallel?
• Other platform functionalities like video recommendation service which recommends/suggests users the next videos they can watch etc.

Q #14) Design an efficient system for operating 6 elevators and ensure a person has to wait for a min time while waiting for the lift to arrive?

Answer: These types of system design questions are more low level and would expect the candidate to think through the elevator system first and list down all possible functions that need to be supported and design/create classes and DB relationships/schemas as the solution.

From the SDET perspective, the interviewer would just expect the main classes that you think your application or system would have and the basic functionalities would be handled with the suggested solution.

Let’s look at the various functionalities of the elevator system that would be expected

You can ask clarifying questions like

• How many floors are there?
• How many elevators are there?
• Are all elevator service/passenger lifts?
• Are all elevators configured to be stopped on each floor?

Here are the different use cases that are applicable for a simple elevator system:

In terms of core classes/objects of this system, you can consider having:

• User: Deals with all the properties of a user and actions that they can take on Elevator Object.
• Elevator: Elevator Specific properties like height, width, elevator serial number.
• Elevator Door: All things related to the door like no doors, type of door, automatic or manual, etc.
• Elevator Button Control: Different buttons/controls available in the elevator and different states that those controls can be in.

Once you are done designing classes and their relationships, you can talk about configuring DB schemas.

Another important component of the Elevator system is the Eventing System. You can talk about implementing queues or in a more complex setup creating event streams using Apache Kafka where the events are delivered to respective systems to be acted upon.

The Eventing System is an important aspect as there are multiple users (on different floors) using the lift at the same time. Hence, the user’s requests should be queued and served as per the configured logic in the Elevator controllers.

Q #15) Design Instagram/Twitter/Facebook.

Answer: All these platforms are in a way related since they allow users to be connected in some way or another and share things via different media types – like messages/videos and chats as well.

So, for these types of social media applications/platforms, you should include the below points while discussing designing such systems (in addition to what we have discussed for designing URL shortener systems):

• Capacity Estimation: Most of these systems would be read-heavy, hence capacity estimation is required and would enable us to ensure that appropriate server and database configuration is ensured to serve the required load.
• DB schema: The main important DB schemas that should be discussed are – User details, User relationships, Message schemas, Content Schemas.
• Video and Image Hosting servers: Most of these applications have videos and images shared across users. Hence the Video and Image Hosting servers should be configured as per need.
• Security: All these apps should ensure a high level of security owing to the User info/Personally Identifiable Information of the users they store. Any attempts of hacking, SQL Injection should not be successful on these platforms as it might cost losing the data of millions of customers.

Scenario-based problems

Scenario-based problems are generally for senior-level folks, where different real-time scenarios are given and the candidate is asked their thoughts about how they will handle such a situation.

Q #16) Given a critical hotfix needs to be released as soon as possible – what kind of testing strategy would you have?

Answer: Now, here the interviewer essentially wants to understand

• What kind of test strategies can you think of and how?
• What coverage would you do for a hotfix?
• How would you validate the hotfix post-deployment? etc.

To answer such questions, you could use real-life situations if you could relate to the problem. You should also mention that without appropriate testing, you would not be willing to release any code to production.

For critical fixes, you should always work in tandem with the developer to try to understand what areas it could impact and prepare a non-production environment to replicate the scenario and test the fix.

It’s also important here to mention that you will continue to monitor the fix (using monitoring tools, dashboards, logs, etc.) post-deployment to see any abnormal behavior in the production environment and ensure that there is no negative impact of the fix that’s done.

There might be other questions as well which are mostly to understand the candidate’s perspective on automation testing, delivery timelines, etc. (and these questions can vary from company to company as well as seniority of the role. Generally these questions are asked for senior/lead level roles)

Q #17) Would you sacrifice full testing to release a product fast?

Answer: These questions typically involve the interviewer understanding your thoughts from a leadership perspective and what are the things that you would compromise on, and would you be willing to release a buggy product in lieu of less time.

Answers to these questions should be substantiated against the actual experiences of the candidate.

For example, you could mention that in the past, you had to make a call to release some hotfixes but it could not be tested due to the non-availability of the integration environment. So you release it in a controlled manner – by rolling it out to a smaller percentage and then monitoring logs/events and then initiating a full rollout, etc.

Q #18) How would you create Automation Strategy for a product which has no automation tests at all?

Answer: These types of questions are open-ended and are generally a good place to take the discussion in the way you want to. You can also showcase your skills, knowledge, and technology areas that are your strength.

For example, to answer these types of questions, you can cite examples of the Automation strategies you adopted while building a product in your past role.

For instance, you could mention points like,

• Since the product requires starting automation from scratch, you have enough time to think and design for an appropriate automation framework, choosing a language/technology that most people have the knowledge to avoid introducing a new tool and leveraging existing knowledge.
• You started by automating the most basic functional scenarios that were considered to be P1 (without which no release could go through).
• You also thought about testing the Performance and Scalability of the system through automated test tools like JMETER, LoadRunner, etc.
• You considered automating the security aspects of the application as listed in the OWASP Security standards.
• You integrate automated tests into the build pipeline for early feedback etc.

Team Fit & Culture Fit

This round generally depends on company to company. However, the need/necessity for this round is to understand the candidate from a team and organization culture perspective. The purpose of these questions is also to understand the candidate’s personality and their approach towards work/people etc.

Generally, HR and Hiring managers are the ones that conduct this round.

Questions that typically come up during this round are like:

Q #19) How do you resolve conflicts within your current role?

Answer: Further explanation here is: suppose you have a conflict with your boss or immediate team members, what are the steps you take to resolve those conflicts?

For this type of question substantiate as much as you can with real examples that might have happened within your career at current or previous organizations.

You can mention things like:

• We would like to sort out any conflicts as soon as possible for professional reasons (and would not like to affect your personal relations due to these).
• You can mention that you generally try to communicate effectively and talk/discuss with the person individually to resolve any differences/issues.
• You can mention that if things start getting worse, you would take the help of a senior person/your manager and get his/her input.

Other examples of team fit/culture fit questions are below (most of them should be answered in a similar approach we discussed for the question above. Talking about real-life scenarios is key here as the interviewer can relate it in a better way as well.

Q #20) What kind of work-life balance do you expect from the new role that you are considered to be hired for?

Answer: Since the Hiring Manager is someone who knows what the role demands, how much extra effort might be required at times, in general the interviewer tries to gauge if your expectations are radically different from what the role expects.

Suppose you say that you don’t prefer to attend night meetings and the role expects you to have major collaboration between a team that sits in a different time zone, then the interviewer might initiate a discussion that these are the expectations from the role – Will you be able to adapt? etc.

So again, this is more of a casual conversation but from the interviewer’s perspective, they want to understand your expectations to evaluate your candidature for the position being interviewed for.

Q #21) Aside from work, what are your hobbies?

Answer: These questions are purely subjective and individual-specific, and these questions are generally useful to make the candidate feel relaxed and easy and initiate casual discussions.

In general, the answers to these questions could be like – you like to read a particular genre, you like music, you received some award for some voluntary/philanthropy activity, etc. Also, these questions are generally asked in the HR round (and are less likely to be asked by a technical person).

Q #22) How much time are you willing to devote to learning new tools and technologies proactively?

Answer: Here the interviewer is gauging your willingness to learn new stuff if something unusual or new is thrown at you. It also lets the interviewer know that you are proactive? Are you willing to invest in yourself and your career? etc.

So while answering such questions – be honest and substantiate your answers with examples – For example, You could mention that you appeared for a Java certification last year and prepared yourself outside of work by taking a few hours every week.

Conclusion

In this article, we discussed the Software Development Engineer in the Test interview process and sample questions that are generally asked from the candidates across different organizations and profiles. In general, SDET interviews are very broad in nature and are a lot dependent on the company to company.

But the interview process is similar to what’s there for a developer profile with a greater emphasis on quality and automation frameworks.

It’s important to understand that, nowadays companies are less focused on any specific language or technology, but more about a broad understanding of concepts and the ability to adapt to the tools/technologies required by the company.

Best wishes for your SDET Interview!