Zscaler Interviews

My Zscaler SDE Internship Interview Experience

Round 1: HackerRank Online Assessment

Round 2: Technical Interview 1 (Google Meet)

• Remove Nth Node From End of List
• Maximum Path Sum (likely in a binary tree)

Round 3: Technical Interview 2 (Google Meet)

• A problem to Minimize the Sum, which the interviewer indicated was a heap-based question.
• A bit manipulation question involving non-primitive data types, though I can't recall its specifics.

Verdict: Rejected

I hope my experience can be helpful to others going through similar interview processes.

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.

• 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.

• 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.

• 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).

My Interview Experience at Zscaler

My interview journey for the Developer C Intern role at Zscaler began with an on-campus opportunity. Here's a breakdown of the rounds I went through:

ROUND 1 - Online Assessment

The online assessment primarily focused on implementation-based questions. I encountered problems that required proficient use of HashMaps, demonstrated knowledge of Trie data structures, involved Greedy algorithms often paired with Heaps, and dynamic programming questions, particularly those based on Longest Increasing Subsequence (LIS) concepts.

ROUND 2 - Interview 1

The first interview delved into my C language proficiency, with a significant emphasis on pointers. I was also asked to solve specific coding challenges. The interviewer provided me with the following problems:

• Find the element in an array that appears an odd number of times.
• Find the sum of all divisors of the Greatest Common Divisor (GCD) of all elements in an array.
• Merge all overlapping intervals from a given collection.

ROUND 3 - Interview 2

This round was a comprehensive test of my theoretical knowledge. I faced around 10-15 questions each on Operating Systems, Computer Networks, and C Programming Language. In addition to these conceptual questions, I was given a coding problem:

• Find the Longest Common Subsequence of two given strings.

ROUND 4 - Interview 3

The final technical interview focused on a specific implementation task. I was challenged to implement Run Length Encoding, with the strict requirement that it had to be done in C language.

Round 1 - Online Assessment

My first hurdle was an online assessment that featured implementation-based questions, specifically requiring the use of HashMaps. I also encountered problems related to Tries, greedy algorithms often solved with Heaps, and dynamic programming questions based on Longest Increasing Subsequence concepts.

Round 2 - Interview 1

The first interview round delved deeply into C language concepts, particularly pointers. I was also asked to solve two coding problems: 'Find element having odd frequency' and 'Find sum of all divisors of GCD of array elements,' along with 'Merge Intervals.'

Round 3 - Interview 2

The second interview round was quite extensive, with 10-15 questions each on Operating Systems, Computer Networks, and C Programming Language. Additionally, I had to tackle a coding problem: 'Longest Common Subsequence of 2 strings.'

Round 4 - Interview 3

The final interview round focused on implementing 'Run Length Encoding', with a strict requirement to use the C language for the solution.

Verdict: I was ultimately selected for the role, which was an on-campus opportunity.

As a fresh graduate with a B.Tech in Electronics and Communication Engineering from a Tier 1 college and prior SDE internship experience, I pursued an on-campus placement opportunity at Zscaler for a Software Developer C/C++ role in Bangalore. The entire process concluded with an offer on November 16th, 2023, which I happily accepted.

Online Assessment (Online Coding Round)

The online assessment consisted of three coding questions of medium to hard difficulty, focused on problem-solving and DSA, with a total time of 90 minutes. The topics revolved around BFS (Graphs) + Binary Search, DP on Trees (which I solved using centroid of a tree), and Segment Tree + Binary Search. I successfully solved two out of the three questions (the first and second ones) but ran out of time for the third. Shortlisted students were announced approximately 40-50 days after this round.

Technical Round 1

The interviewer started warmly, asking about my breakfast before quick introductions. I rated myself 9.5 in C++ and 8.5 in C out of 10. The discussion then dived into core concepts of C, Operating Systems, and Computer Networking.

• We extensively covered different Storage Classes (Auto, Extern, Static, Register), discussing their differences, scope, life, and storage locations (Stack, Data Segment, CPU register). I went an extra step to provide coding applications for each, explaining, for instance, that the compiler treats int foo(int a); as extern int foo(int a); and how static limits a function's access to a single file.
• We moved on to Dynamic Memory Allocation, covering its types, syntax, differences, and applications, including a discussion on stack and heap memory segments. The interviewer probed deeper, asking about the internal working of realloc – specifically, whether it assigns a new memory address or just changes the segment size at the same base pointer. I wasn't entirely sure but reasoned that assigning a new address and copying data would prevent overlaps and data corruption, which satisfied him.
• We discussed Structures vs. Unions, their differences, applications, internal working, and padding in structures. I was given two structures to determine their sizes. When asked why padding is used, I explained it in terms of processor architecture (e.g., 32-bit systems reading 4 bytes at a time) to maintain memory layout consistency and increase access efficiency.
• I also answered questions on pointer arithmetic and concepts like dangling pointers, void pointers, and the volatile keyword.
• Quick-fire questions on Operating Systems covered race conditions, semaphores, and memory management concepts such as paging and thrashing.
• We then discussed Computer Networking Concepts, including SSL, Certificates, the 3-way handshake, TCP flags, DNS, and encryption (public and private key).
• The interviewer appreciated my Competitive Programming profile but wanted to assess my C coding skills, so he gave me a pattern matching string-based question. I first explained the O(N^2) brute-force approach and coded it in C. When asked for optimization, I briefly explained the Rabin-Karp algorithm, which he was satisfied with.

The interview concluded with me asking questions about Zscaler's products and lasted about 80 minutes. I felt confident about my performance, having answered all questions extensively. I successfully cleared this round.

Technical Round 2

This round also started pleasantly with introductions. The interviewer began with basic data structure concepts and gradually increased the complexity, later including Computer Networking and a coding question.

• I explained the difference between arrays and linked lists based on their use-cases.
• I was asked about binary search and tasked with proving its time complexity.
• I provided a mathematical proof for the working of the Hare and Tortoise algorithm (Floyd's cycle-finding algorithm) for cycle detection in a linked list.
• We discussed the internal working of C++ unordered_maps. I explained hashing keys (using modulo M), collision resolution with an array of linked lists, and rehashing. The interviewer then posed a modification: what if M is very small, rehashing is not used, and insertion/search complexity is limited to O(log N)? This was an indirect hint towards ordered maps (Red-Black Trees). I logically constructed a solution using an array of BSTs, which pleased the interviewer more than a memorized solution.
• Extensive and in-depth discussions on Computer Networking included Gateways, Routing vs. Switching, MAC address, Network Interface Cards (NICs), and ARP. I explained how a computer determines it must go to a gateway by comparing subnet IDs based on IP addresses, subnet masks. We also covered CIDR-related IP questions and the 4-phase handshaking in an SSL handshake.
• Finally, a coding question required me to implement a custom malloc and free in C. I later realized it's a standard problem. Despite not having solved it before, with a couple of hints, I successfully provided and coded a robust O(1) time complexity solution, which satisfied the interviewer.

The interview ended positively with me asking about the potential work. This round lasted about 75 minutes. I was selected for the role.

My Thoughts

My key takeaway from this experience is to always make an extra effort to elaborate on concepts, even if not directly asked, ensuring relevance and staying on topic.

Compensation offered:

• Stipend during 6 months internship: INR 50,000 per month + Wifi Reimbursement
• CTC for full time: INR 28.5 Lacs (14Lacs base + 2 Lacs joining bonus and 15k USD worth ESOPS)
• Other benefits (apart from CTC) include Relocation, Medical Insurance, Wifi Reimbursement, Free Meals (3x a day and unlimited snacks), Employee Wellness, etc.

My Zscaler Interview Journey: UI Developer (Internship + FTE)

I participated in an on-campus opportunity for a UI Developer role, which included both an internship and a full-time offer. The entire interview process was quite extensive, unfolding over approximately 8-10 days.

Round 1: Coding Round

This round was about 2 hours long. It started with several MCQs related to HTML, CSS, and JavaScript. Following the MCQs, I faced three coding questions. One specific question involved DOM manipulation, where I needed to pass several test cases. I managed to solve all questions, though one test case in the DOM manipulation problem remained elusive.

After about a week, the results were announced, and I was thrilled to be shortlisted for the subsequent rounds.

Round 2: Technical Round

This round began with my introduction, followed by a detailed discussion about my previous internships and projects. The interviewer then shifted focus to HTML and CSS, and later delved deeply into JavaScript. We discussed how JavaScript works internally, its execution model, and many other intricate details. He asked me to write a JavaScript Promise, and then cross-questioned me extensively about its implementation and asynchronous programming concepts. Towards the end, he posed an easy DSA question: remove duplicate elements in an array. He preferred the solution in JavaScript, but since I wasn't well-versed in DSA using JavaScript, I explained different approaches in C++. He seemed satisfied and then proceeded to explain the JavaScript implementation to me.

Round 3: Technical Round

Right after my introduction, this round quickly turned into a rapid-fire session. The interviewer barraged me with numerous questions on React, CSS, and JavaScript. I recall questions about Error Boundaries in React, Polyfilling in JavaScript, Debouncing, the difference between null and undefined, and local and session storage. Finally, he shared a HackerRank CodePair link containing pre-written React code and asked me to make specific modifications, which I successfully completed.

Round 4: Technical + HR Round

This was the easiest round, led by a manager. He started by explaining the company and the role, followed by my introduction. The discussion then revolved around my internship experience; since I had worked in a backend team, he was keen to understand my motivation for applying to a frontend role. This discussion lasted for a while. He also asked me to elaborate on a project I worked on during my internship. Subsequently, he touched upon the basics of HTML, CSS, ReactJS, and JavaScript. The round concluded in about 40 minutes.

About 4-5 days later, a list of selected students was shared, and I was delighted to find my name on it.

Keep Working Hard!!!