Delhivery Interview Preparation and Recruitment Process

Sample Answer (Customizable):

"I want to join Delhivery because it’s one of the most innovative and fast-growing logistics companies in India. I admire how Delhivery uses technology and data-driven solutions to solve real-world supply chain problems. The company’s vision to redefine logistics in India and globally really aligns with my own interests in tech-enabled operations and problem-solving.

I’m excited by the opportunity to be part of a team that values efficiency, customer-centricity, and innovation. I believe Delhivery’s fast-paced, dynamic environment would be a great place to learn, contribute, and grow professionally."

You Can Personalize It Based On:

Delhivery is one of India’s leading logistics and supply chain companies, founded in 2011. It started as a hyperlocal delivery service but quickly evolved into a full-stack logistics provider.

The company offers a wide range of services including:

• Parcel transportation (for e-commerce and businesses)

• Warehousing & fulfillment

• Freight services (including PTL/FTL)

• Cross-border logistics

• Supply chain software solutions

What sets Delhivery apart is its strong focus on technology and automation — they use AI, data analytics, and real-time tracking to optimize deliveries and reduce turnaround time. They have one of the largest pan-India delivery networks and are known for serving not just metro cities, but also remote areas across India.

They’ve also made key acquisitions and partnerships to expand capabilities, including Spoton Logistics, and went public with an IPO in 2022. Their goal is to become a fully integrated logistics player — flexible, tech-first, and scalable.

Situation: During my final year project, we were working on a web app with a tight 2-week deadline. One week in, our main developer had a personal emergency and couldn't continue.

Task: As the team lead, I had to ensure the project stayed on track without compromising quality, despite being down a key team member.

Action: I reassigned tasks based on everyone’s strengths, took on additional coding myself, and kept in constant communication with the team to make sure everyone was aligned. I also worked late hours to fill the gaps, especially on the backend functionality.

Result: We completed the project just in time, delivered a functional prototype, and even received appreciation for the UI and presentation. More importantly, I learned how to stay calm under pressure, adapt quickly, and support a team through a crisis.

I handle pressure and tight deadlines by staying organized, focused, and maintaining a calm mindset. When I know time is limited, I start by breaking the task into smaller, manageable parts and prioritize based on urgency and impact.

I also make sure to communicate clearly with my team or manager about progress, any blockers, and realistic expectations. If needed, I don’t hesitate to put in extra effort to meet the deadline — but I always ensure quality doesn’t suffer.

One thing I’ve learned is that pressure often comes from uncertainty — so by planning ahead, staying focused, and being adaptable, I can deliver even in high-pressure situations.

The functionalities of different layers of the OSI model are :

#include<stdbool.h>
#include<iostream>
using namespace std;
#include<string>

class node{
public:
 int data;
 class node* next;

 node()
 {
     data=0;
      next=NULL;
 }
}*top=NULL;

class Stack{

    public:

void push(int x){
       node *p=new node;
    if(top==NULL){

     p->data=x;
     p->next=NULL;
     top=p;}
     else{

     p->data=x;
     p->next=top;
     top=p;
     }
 }

 int pop(){
    int ch;
    ch=top->data;
    top=top->next;
    return ch;
 }

 bool isempty(){
 if(top==NULL){
 return true;}
 else{
    return false;
 }
 }

};

void stkspan(int arr[],int n){
    Stack st;
    int arr1[n];
    arr1[0]=1;
    st.push(0);
    for(int i=1;i<n;i++){

            while(st.isempty()==false && arr[i]>=arr[top->data])
            {
                st.pop();
            }
            if(st.isempty()==true)
            {
                arr1[i]=i+1;
            }
            else{
            arr1[i]=i-top->data;
            }
             st.push(i);

    }
    for(int j=0;j<n;j++)
    {
        cout<<arr1[j]<<endl;
    }
}

int main()
{
    int n;

cin>>n;
int *arr=new int[n];

for(int i=0;i<n;i++){
    cin>>arr[i];
}
stkspan(arr,n);
}​

#include<iostream>
using namespace std;
class Interviewbit
{
      
public:
int pow_function(int a, unsigned int b)
{  int x;
    if (b == 0){
        return 1;
    }
     x=pow_function(a, b / 2);
     if (b % 2 == 0){
        return x * x;}
    else{
        return a * x * x;
    }
}
};
 
int main()
{
    Interviewbit i;
    int a = 4;
    unsigned int b = 6;
 
    cout << i.pow_function(a, b);

}​

Here's a simple program in Python to create a binary tree and insert a new node in level order (i.e., fill the tree from left to right, top to bottom):

Binary Tree Level-Order Insertion (Python)

from collections import deque

# Define a Node
class Node:
    def __init__(self, key):
        self.data = key
        self.left = None
        self.right = None

# Function to insert a new node in level order
def insert_level_order(root, key):
    if not root:
        return Node(key)

    queue = deque()
    queue.append(root)

    while queue:
        temp = queue.popleft()

        if not temp.left:
            temp.left = Node(key)
            return root
        else:
            queue.append(temp.left)

        if not temp.right:
            temp.right = Node(key)
            return root
        else:
            queue.append(temp.right)

# Helper function to do level order traversal (for visualization)
def level_order_traversal(root):
    if not root:
        return []

    result = []
    queue = deque()
    queue.append(root)

    while queue:
        node = queue.popleft()
        result.append(node.data)

        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)

    return result

# Example Usage
if __name__ == "__main__":
    # Create a simple tree
    root = Node(10)
    root.left = Node(11)
    root.left.left = Node(7)
    root.right = Node(9)
    root.right.left = Node(15)
    root.right.right = Node(8)

    print("Level order before insertion:", level_order_traversal(root))

    key_to_insert = 12
    insert_level_order(root, key_to_insert)

    print("Level order after insertion:", level_order_traversal(root))

How It Works:

• It uses a queue to perform level order traversal.

• It checks each node’s left and right child.

• The first place it finds a missing child (None), it inserts the new node.

Sure! Here's a simple program in Python to check if a number is a palindrome — meaning it reads the same backward as forward.

Python Code: Check Palindrome Number

def is_palindrome(num):
    # Convert number to string
    str_num = str(num)
    
    # Compare with its reverse
    return str_num == str_num[::-1]

# Example usage
number = 121
if is_palindrome(number):
    print(f"{number} is a palindrome.")
else:
    print(f"{number} is not a palindrome.")

Explanation:

• We convert the number to a string.

• Then compare it with its reversed version using slicing ([::-1]).

Optional: Without converting to string

If you want a pure number-based solution, here’s how:

def is_palindrome_number(num):
    original = num
    reversed_num = 0

    while num > 0:
        digit = num % 10
        reversed_num = reversed_num * 10 + digit
        num //= 10

    return original == reversed_num

# Example usage
number = 12321
if is_palindrome_number(number):
    print(f"{number} is a palindrome.")
else:
    print(f"{number} is not a palindrome.")

Sure! Here's a simple recursive function in Python to calculate the factorial of a number.

Python Code: Factorial Using Recursion:

def factorial(n):
    # Base case
    if n == 0 or n == 1:
        return 1
    # Recursive case
    return n * factorial(n - 1)

# Example usage
num = 5
print(f"Factorial of {num} is {factorial(num)}")

How It Works:

• factorial(5) → 5 * factorial(4)

• factorial(4) → 4 * factorial(3)

• ... until it hits the base case: factorial(1) → 1

So:

factorial(5) = 5 * 4 * 3 * 2 * 1 = 120

Sure! Here's a simple program in Python to find the largest element in an array:

Python Code: Find Largest Element in an Array

def find_largest(arr):
    if not arr:
        return None  # Handle empty array

    largest = arr[0]

    for num in arr:
        if num > largest:
            largest = num

    return largest

# Example usage
arr = [10, 45, 3, 99, 23, 67]
print(f"The largest element is: {find_largest(arr)}")

Explanation:

• Start by assuming the first element is the largest.

• Loop through the array and update if a bigger number is found.

Output for the example:

The largest element is: 99

#include <bits/stdc++.h>
using namespace std;
 
class Stack{  
    public:
        int top;  
       int size;  
        char* array;  
};  
 
Stack* Stack_create(unsigned size){
    
    Stack* new_stk = new Stack();
    new_stk->size= size;  
    new_stk->top = -1;  
    new_stk->array = new char[(new_stk->size * sizeof(char))];  
    return new_stk;  
}  
 
int stackfull(Stack* stk){
    return stk->top == stk->size - 1;
}  
 
int stackempty(Stack* stk){
    return stk->top == -1;
}  
 
void push(Stack* stack, char item){  
    if (stackfull(stack))  
        return;  
    stack->array[++stack->top] = item;  
}  
 
char pop(Stack* stk){
    if (stackempty(stk))  
        return -1;  
    return stk->array[stk->top--];  
}  
 
void string_reverse(char p[]){  
    int n = strlen(p);  
    Stack* stk = Stack_create(n);  
 
    int i;  
    for(i = 0; i < n; i++){  
        push(stk, p[i]);
    }    
 
    for(i = 0; i < n; i++){  
        p[i] = pop(stk);
    }    
}  
 
int main(){  
    char p[] = "Welcome_To_InterviewBit";  
 
    string_reverse(p);  
    cout<<p<<endl;  
 
}​

mat[n][n] = { {1, 2, 3}, { 7,8,9  }, {  10, 11, 12 }, };​

10 7 1
11 8 2
12 9 3 ​

#include <iostream>
using namespace std;
const int n = 3;
void print(int given_matrix[n][n])
{
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << given_matrix[i][j] << " ";
        cout << endl;
    }
}
void rotate_a_matrix_by_90_degrees(int given_matrix[n][n])
{

    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            swap(given_matrix[i][j], given_matrix[j][i]);
 
    for (int i = 0; i < n; i++) {
        int left = 0, right = n - 1;
        while (left < right) {
            swap(given_matrix[i][left], given_matrix[i][right]);
            left++;
            right--;
        }
    }
}
int main()
{
    int given_matrix[n][n]
        = { {1, 2, 3},
                      { 7,8,9  },
                      {  10, 11, 12 },
                      };
    rotate_a_matrix_by_90_degrees(given_matrix);
    print(given_matrix);
}​

#include<bits/stdc++.h>
 
void function_for_missing(int nums[], int n)
{
 
    int XOR = nums[0];
    for (int i = 1; i < n-2; i++)
        XOR ^= nums[i];
    for (int i = 1; i <= n; i++)
        XOR ^= i;
 
    int set_bit_no = XOR & ~(XOR-1);

    int a = 0, b = 0;
    for (int i = 0; i < n-2; i++)
    {
        if (nums[i] & set_bit_no)
            a = a ^ nums[i];
        else
            b = b ^ nums[i];
    }
    for (int i = 1; i <= n; i++)
    {
        if (i & set_bit_no)
            a = a ^ i;
        else
            b = b ^ i;
    }
 
    printf("The numbers which are not present are\n %d %d", a, b);
}
 
int main()
{
    int nums[] = {1, 3, 5, 6};
 
    int n = 2 + sizeof(nums)/sizeof(nums[0]);
 
    function_for_missing(nums, n);
 
    return 0;
}​

#include <bits/stdc++.h>
using namespace std;
 
int check(string s1, string s2)
{
    int version1 = 0, version2 = 0;

    for (int i = 0, j = 0; (i < s1.length()
                            || j < s2.length());) {
   
        while (i < s1.length() && s1[i] != '.') {
            version1 = version1 * 10 + (s1[i] - '0');
            i++;
        }
 
        while (j < s2.length() && s2[j] != '.') {
            version2 = version2 * 10 + (s2[j] - '0');
            j++;
        }
        if (version1> version2)
            return 1;
        if (version2 > version1)
            return -1;

        version1 = version2= 0;
        i++;
        j++;
    }
    return 0;
}
 
int main()
{
    string s1 = "0.5.3";
    string s2 = "0.5.7";
 
    if (check(s1, s2) < 0)
        cout << s1 << " is smaller\n";
    else if (check(s1, s2) > 0)
        cout << s2 << " is smaller\n";
    else
        cout << "Both version are equal\n";
   
}​

To fetch the second highest salary from a table in SQL, here's a clean and commonly used query:

SQL Query (Using DISTINCT and LIMIT / OFFSET):

SELECT DISTINCT salary
FROM employees
ORDER BY salary DESC
LIMIT 1 OFFSET 1;

Explanation:

• ORDER BY salary DESC → Sorts salaries in descending order.

• LIMIT 1 OFFSET 1 → Skips the highest salary (OFFSET 1) and returns the next one.

Table Assumption:

Assuming your table is named employees and has a column called salary.

Alternate Version (Using MAX with Subquery):

SELECT MAX(salary) AS second_highest_salary
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

Notes:

• The second query works even if there are duplicate salaries.

• Use DISTINCT if the table contains duplicate salary entries and you want to ignore them.