Zscaler | Intern + FTE | Oncampus | 2023

I applied to Zscaler and went through the interview rounds in the fall of 2023 for a 2024 Batch Intern + FTE position. I recently compiled my notes to share my experience across the various rounds. The interviews focused on Computer Networks, Data Structures & Algorithms, Operating Systems, C and C++ Programming, and Object-Oriented Programming.

Round 1: Online Assessment (HackerRank)
This round was a 2-hour online assessment featuring four Data Structures and Algorithms (DSA) questions.

Round 2: Interview Round 1
This interview lasted 1 hour and 10 minutes. It began with a basic introduction, followed by discussions about my projects and internships. The interviewer then delved into several technical areas:

• VPNs: I was asked to explain the differences between personal and enterprise-level VPNs, and to describe the detailed workings of VPNs, including tunneling protocols, encryption, and authentication mechanisms.
• IP Addresses: We discussed implementations and scenarios involving IP addresses, covering differences between IPv4 and IPv6, their addressing schemes, and requirements.
• OSI Model: The interviewer asked questions related to the OSI model, including protocols like DNS and DHCP, and their functions within the model.
• Security: I explained Denial of Service (DoS) attacks and the principles behind asymmetric encryption.
• Smart Pointers: I provided an in-depth explanation of smart pointers, highlighting their benefits over traditional pointers, such as automatic memory management and prevention of memory leaks.
• DSA Question: I worked on a data structures and algorithms problem involving generating all possible palindromes from two strings. The challenge was to combine these palindromes to find the longest and lexicographically smallest one. I initially misunderstood the problem, which led to taking more time to solve it. As a result, the interviewer could only cover this one DSA question instead of the two initially planned.

Overall, the feedback for this round seemed positive. Although I struggled a bit at the start, I answered the questions with good flow once I settled down. The interviewer was particularly impressed by my knowledge of smart pointers, which was unexpected. The only negative aspect was that I took extra time to solve the DSA question, which meant the interviewer could not cover the second DSA question as initially intended.

Round 3: Interview 2
This interview lasted 1 hour and 45 minutes. It began with a brief introduction, followed by an exploration of the following areas:

• Request/Response Troubleshooting: The interviewer asked how I would determine if a machine is down or if the port I sent a request to is not working when there is no response. I proposed a solution involving reverse proxy and load balancing to track nodes and request routing, but the correct answer was to use traceroute to identify the issue.
• Pointer Arithmetic: I was asked how to check if a particular byte is set using pointer arithmetic, discussing pointer increment, high-level data structures, and hexadecimal addresses. My response involved modifying pointer types and incrementing by 1 byte, but I couldn't provide a precise method. The correct approach involves using advanced datatypes like uint_8.
• ARP Protocol: There was an in-depth question related to the working of ARP (Address Resolution Protocol).
• Three-Way Handshake & TLS Handshake: I had to explain the Three-Way Handshake protocol and extend the discussion to the TLS Handshake protocol. I detailed the TCP process and then the more complex TLS handshake.
• TCP vs. UDP: We discussed the differences between TCP and UDP, including their applications and appropriate use cases. I provided a comparison of their characteristics and scenarios for their use.
• Object-Oriented Programming (OOP) Concepts: I was asked to implement various OOP concepts such as inheritance, polymorphism, virtual functions, and function overloading. I focused on dynamic binding and virtual functions, coding various scenarios and explaining the concepts. The interviewer tried to confuse me, but I believe I satisfied him with my responses.
• Data Structures & Algorithms: I was given a problem similar to the Asteroid Collision.
• Data Structures & Algorithms: Another problem was to find the number of strings of length n that can be formed using 'a', 'e', 'i', 'o', 'u' such that 'a' can only come after 'e', 'e' can only come after 'i', and similar adjacency constraints.

I believe I initially struggled in this round by presenting complex, made-up approaches to simple solutions I was not familiar with or could not recall under pressure. However, as the interview progressed, I became more settled and seized every opportunity to make a positive impression. I managed to answer most networking and OOP-related questions effectively. I learned that a lengthy interview can be a good sign, which I hadn't considered before. In retrospect, trying out initial questions with made-up approaches also worked in my favor, as my determination to find a solution demonstrated my problem-solving skills.

Round 4: Interview 3
This interview lasted 1 hour and 30 minutes. As usual, it started with introductions and included the following questions and topics:

• HTTP vs. HTTPS and TLS Handshake: I explained the differences between HTTP and HTTPS, describing HTTP as unencrypted and HTTPS as its secure, TLS-encrypted version. I also explained the TLS handshake process.
• Calling of main() Function: I discussed who calls the main() function (runtime environment/OS) and what happens during the compilation and interpretation of a program.
• Threads vs. Processes: We discussed threads and processes in depth, including thread scheduling vs. process scheduling, and clarified that a single class main() program calling a function does not inherently create a thread. I struggled with the detailed explanation of process and thread scheduling, which seemed to frustrate the interviewer. I recovered by providing examples and apologizing.
• Memory Architecture of a Process: I described the typical memory layout of a process, including stack, heap, data segment, and code segment, and covered memory allocation.
• Object-Oriented Programming (OOP) Concepts: I explained OOP concepts in depth, including abstraction and security, and compared OOP with procedural programming, noting the drawbacks of the latter.
• DSA Question: I implemented a solution for a queue problem where a print function was required for the nth state. This problem involved a complex queue and some log analysis mechanism to analyze logs of very large size. I provided four approaches ranging from brute force to optimized methods, explaining the trade-offs of each. This ended the interview on a positive note.

Despite thinking I had messed up on the threads and processes questions, I was able to impress the interviewer with my four different approaches to the complex queue problem. Overall, I wasn't confident about my chances after this interview, but I still moved forward.

During the interview process, additional questions were asked, and interviewers provided topics for follow-up and further preparation. I've compiled them here:

• Multithreading in C, including how memory management is handled by the OS.
• Extensive discussion on C pointers, including decimal and hexadecimal pointers, and their address allocation.
• C data structures, specifically static integers, memory allocation for 2D arrays, and recursion stored in the stack.
• How to implement maps in C.
• Differences between processes and threads, including system call interfaces and user vs. kernel modes.
• Memory management and architecture, how threads improve process execution efficiency, common shared vs. non-shared resources, and virtual memory limitations.
• A multiprogramming scenario: whether two 2 GB processes could run on a 3 GB, 32-bit architecture.
• C++ specifics: compilation process, differences between C++ and C, and implementation of custom mutexes.
• Network protocols: domain level search, protocols, and OSI model datagram.
• C++ updates: differences between C++17 and C++20, lambda functions, and proxy server vs. IP differences.
• Clarification on the size of void pointers across different system architectures, and that macros are compile-time entities not occupying runtime memory.
• Difference between i = i + 1 and i++ in terms of memory usage and execution time, noting any overheads.
• Structure and size of datatypes in C.
• C storage classes (Auto, Extern, Static, Register).