Zscaler | Intern + FTE | Oncampus | 2023

Graduate: 2024 Batch Hello everyone, I applied to Zscaler and went through the interview rounds in the fall of 2023. Although this post is a bit delayed, I recently found some...

Graduate: 2024 Batch
Hello everyone, I applied to Zscaler and went through the interview rounds in the fall of 2023. Although this post is a bit delayed, I recently found some notes on my interview experiences and decided to compile and share them here. The focus areas for the interview included: Computer Networks, Data Structures & Algorithms, Operating Systems, C and C++ Programming, and Object-Oriented Programming.

Round 1: Online Assessment (HackerRank)

Duration: 2 hours
4 Data Structures and Algorithms (DSA) Questions

Round 2:

Interview Round 1

Duration: 1 hr 10 mins
The interview began with a basic introduction, followed by questions about my projects and internships. The interviewer then explored the following 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: 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.

• My Review: 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 got settled. The interviewer was particularly impressed by my knowledge of smart pointers, which was not expected. 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

Duration: 1 hr 45 mins
The interview began with a brief introduction, followed by the interviewer exploring the following areas:
* Request/Response Troubleshooting:
- Question: How would you determine if a machine is down or if the port you sent a request to is not working when there is no response?
- My Response: Proposed a solution involving reverse proxy and load balancing to track nodes and request routing.
- Correct Answer: Use traceroute to trace the path and identify where the issue lies.
* Pointer Arithmetic:
- Question: How would you check if a particular byte is set using pointer arithmetic? Discussed pointer increment, high-level data structures, and hexadecimal addresses.
- My Response: Suggested using a modification of pointer types to access a specific byte and incrementing the pointer by 1 byte. However, I was unable to provide a precise method.
- Correct Answer: Use advanced datatypes like uint_8 to handle pointer arithmetic precisely.
* ARP Protocol: In-depth question related to ARP (Address Resolution Protocol) working.
* Three-Way Handshake & TLS Handshake:
- Question: Explain the Three-Way Handshake protocol and extend the discussion to the TLS Handshake protocol.
- Response: Detailed the TCP Three-Way Handshake process and then extended the discussion to the more complex TLS Handshake process used for secure communications.
* TCP vs. UDP:
- Question: Discuss the differences between TCP and UDP, including their applications and appropriate use cases.
- Response: Provided a comparison of TCP (reliable, connection-oriented) and UDP (unreliable, connectionless), and described scenarios for their use.
* Object-Oriented Programming (OOP) Concepts:
- Question: Implement various OOP concepts such as inheritance, polymorphism, virtual functions, and function overloading.
- Response: Implemented these concepts, focusing on dynamic binding and the use of virtual functions to achieve polymorphism. The interviewer had me code various OOP scenarios, asked me to modify them for different use cases, and demanded concrete explanations of the concepts. He also attempted to confuse me, probably to test my understanding, but was ultimately satisfied with my responses.
* Data Structures & Algorithms:
- Question: Problem similar to the Asteroid Collision.
- Question: Find the number of strings of length n that can be formed using the characters a, e, i, o, u such that a can only come after e, e can only come after i, and similar adjacency constraints.

• My Review: This time, I believe I initially struggled 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

Duration: 1 hr 30 mins
As usual, the interview started off with the introductions and the interview included the following questions and topics:
- HTTP vs. HTTPS and TLS Handshake:
- Question: Explain the differences between HTTP and HTTPS. How does a TLS handshake work?
- Response: Described HTTP as an unencrypted protocol and HTTPS as its secure version, which uses TLS for encryption. Explained the TLS handshake process, including the steps of key exchange, authentication, and session encryption.
- Calling of main() Function:
- Question: Who calls the main() function, and what happens during the compilation and interpretation of a program?
- Response: Explained that the runtime environment or operating system typically calls the main() function. Discussed the compilation process (preprocessing, compilation, assembly, linking) and the execution of the program.
- Threads vs. Processes:
- Question: Discuss threads and processes in depth. Is there thread scheduling or process scheduling? If a single class main() program calls a function, will it involve threads?
- Response: Explained the differences between threads (lightweight, share resources) and processes (independent, heavier). Discussed thread scheduling and process scheduling, and clarified that a single class main() program calling a function does not inherently create a thread.
- Memory Architecture of a Process:
- Question: Discuss the memory architecture of a process in depth.
- Response: Described the typical memory layout of a process, including the stack, heap, data segment, and code segment. Covered memory allocation and management within these segments.
- Object-Oriented Programming (OOP) Concepts:
- Question: Explain OOP concepts in depth, including the use of abstraction and security aspects. Why is OOP preferred over procedural programming? What were the drawbacks of procedural programming?
- Response: Discussed OOP concepts such as encapsulation, inheritance, and polymorphism. Emphasized abstraction for simplifying complex systems and enhancing security. Compared OOP with procedural programming, noting that procedural programming can lead to less modular code and difficulties in managing complex interactions.
- DSA Question:
- Question: Implement a solution for a queue problem where the print function was required for the nth state. This problem involved a complex queue and some log ananlysis mechanism to analyse logs of very large size. (since it\'s quite some time I don\'t remember the problem exactly)
- Response: Provided four approaches ranging from brute force to optimized methods for solving the problem, explaining the trade-offs of each approach.
- Question: Discussed a problem involving string subsequences.

• My review: This interview started smoothly, but I struggled with the questions on processes and threads. The interviewer wanted a detailed explanation of process and thread scheduling, which I didn\u2019t fully grasp, and this seemed to frustrate the interviewer. I managed to recover by providing some examples and apologizing. Despite thinking I had messed up, I was able to impress the interviewer by presenting four different approaches to the complex queue problem, which ended the interview on a positive note. Overall, I was not confident about my chances after this interview, but...

During the interview process, additional questions were asked, and the interviewers provided some topics for follow-up and further preparation for upcoming rounds. I was not able to include everything in the roundwise summaries, so I\u2019ve created this custom section to encompass all the remaining details about the interview. You can use this section for further preparation:
- Multithreading in C: Discussed achieving multithreading in C and noted that memory management is handled by the OS.
- C Language Specifics:
- Extensive discussion on C pointers, including decimal and hexadecimal pointers, and their address allocation.
- C data structures: Discussed static integers, memory allocation for 2D arrays, and recursion stored in the stack.
- C map implementation: Covered how to implement maps in C.
- Process vs. Thread: Covered differences between processes and threads, including system call interfaces and user vs. kernel modes.
- Memory Architecture: Discussed memory management and architecture, including how threads improve process execution efficiency, common shared vs. non-shared resources, and virtual memory limitations.
- Multiprogramming: If two 2 GB processes could run on a 3 GB, 32-bit architecture.
- C++ Specifics: Discussed C++ compilation process, differences between C++ and C, and implementation of custom mutexes.
- Network Protocols: Reviewed domain level search, protocols, and OSI model datagram.
- C++ Updates: Reviewed differences between C++17 and C++20, lambda functions, and proxy server vs. IP differences.
- Memory Management: Clarified the size of void pointers across different system architectures, and explained that macros are compile-time entities and do not occupy runtime memory.
- Concentrate on understanding C++ specifics, including why certain programming paradigms are preferred, and be familiar with language internals.
- Memory Storage of Macros: Clarified where macros are stored in memory and how they are used in a program.
- Size of Void Pointer: Discussed the typical size of a void* pointer for different system architecture.
- Difference between i = i + 1 and i++: Explained the difference in terms of memory usage and execution time, noting that i++ incurs a slight overhead due to the creation of a temporary object.
- Memory Management by OS
- Decimal and Hexadecimal Pointers
- String Address Allocation
- System Call Interface (User Mode vs Kernel Mode)
- Structure and Size of Datatypes in C
- Storage Classes (Auto, Extern, Static, Register)

Verdict I was selected!

Upvote, if you find it useful