gep worldwide logo
Gep Worldwide· Technology Intern

GEP Worldwide-Technology Intern

Location
India
Posted
4 Sept 2026
64 reads

Summary

I completed a 2-month Technology Intern interview process at GEP Worldwide, cleared the online assessment, two technical rounds and an HR discussion, and received an offer.

How it went

GEP Worldwide | Technology Intern (2 Months) | On-Campus | Offer


Round 0: Online Assessment (OA)

  • Duration: ~60 Minutes
  • Platform: Online Test Platform

Sections:

  1. Quantitative & Logical Aptitude: Standard numerical reasoning questions with an emphasis on Time & Work problems.
  2. CS Fundamentals: MCQs covering OOP concepts, Database Normalization, Indexing, and standard SQL queries.
  3. Coding Question (1 Problem):
    • Problem: Missing Number (Given an array of size n-1 containing numbers from 1 to n, find the single missing number).
    • Solution Discussion:
      • Sorting: $O(N \log N)$ time, $O(1)$ space
      • Hash Set: $O(N)$ time, $O(N)$ space
      • Optimal Math Approach: $O(N)$ time, $O(1)$ space using $\frac{n(n+1)}{2} - \sum \text{nums}$
      • Optimal Bitwise Approach: $O(N)$ time, $O(1)$ space using XOR to prevent integer overflow:
        int missingNumber(vector<int>& nums) {
            int n = nums.size() + 1;
            int xorVal = 0;
            for (int i = 1; i <= n; i++) xorVal ^= i;
            for (int x : nums) xorVal ^= x;
            return xorVal;
        }
        

Round 1: Technical Interview (15 Minutes)

  • Mode: MS Teams + Notepad (No IDE / Compiler)

1. Introduction & Domain Scoping

  • My background is in Artificial Intelligence. The interviewer immediately asked whether my work focuses on Foundational AI (mathematics, loss functions, pre-training) or Applied AI (fine-tuning, application engineering, RAG pipelines).
  • Clarified that my focus is on Applied AI, directing the technical discussion toward production architectures.

2. Applied AI & LLM Systems

  • RAG Architecture: High-level pipeline, vector embeddings, chunking, and handling hallucination.
  • Vector Stores & ChromaDB: Embeddings generation, vector indexing, distance metrics (Cosine Similarity vs. Euclidean Distance).

3. Live Coding on Notepad: Remove Duplicates from Sorted Array

  • Problem: Given a sorted vector containing duplicates (e.g., [1, 1, 1, 2, 2, 3, 3]), modify it in-place so each element appears only once.

  • Approaches Discussed:

    • std::set: $O(N)$ auxiliary space
    • std::unordered_map: $O(N)$ auxiliary space
    • Two Pointers ($O(N)$ time, $O(1)$ space): Keep slow pointer i at unique boundaries, scan fast pointer j, assign arr[++i] = arr[j].
  • C++ STL Follow-up:

    • The interviewer asked about the built-in C++ method for this.
    • Answer: std::unique from <algorithm> (Erase-Remove Idiom):
      #include <vector>
      #include <algorithm>
      
      vector<int> arr = {1, 1, 1, 2, 2, 3, 3};
      auto it = unique(arr.begin(), arr.end());
      arr.erase(it, arr.end()); // arr is now [1, 2, 3]
      
  • Verdict: Advanced to Round 2. Advised to stay relaxed and keep steady composure.


Round 2: Technical & Leadership Round (20 Minutes)

  • Interviewer: Principal Software Engineer (12+ years at GEP)
  • Format: High-intensity rapid-fire verbal round (30+ questions in ~15 minutes) with zero latency to test spontaneous recall.

1. Prior Round Verification

  • Interviewer asked who took my Round 1 and had me summarize every single topic and problem discussed.

2. DBMS Fundamentals

  • Difference between WHERE and HAVING clauses.
  • An advanced/niche database concept: I had not encountered it, so I stated clearly: "Sir, I have not worked with this particular concept yet." The interviewer appreciated the directness and moved on.

3. Rapid-Fire OOP (30+ Questions)

  • 4 Pillars: Real-world examples and design trade-offs of Abstraction, Encapsulation, Inheritance, and Polymorphism.
  • Encapsulation: Real-world analogies and code patterns (private data members exposed via validated getters/setters).
  • Constructors: Types (Default, Parameterized, Copy), declaration syntax, scopes, and declaration inside classes vs. interfaces.
  • Destructors: Syntax (~), execution lifecycle, and whether destructors can be overloaded (No, only one destructor per class).
  • Polymorphism & Binding: Compile-time (function/operator overloading) vs. Runtime (virtual functions/overriding). Early/Static binding vs. Late/Dynamic binding via vtable and vptr.
  • Interfaces & Abstract Classes: Pure virtual function syntax (= 0) and runtime polymorphism.

4. Data Structures (Verbal Walkthrough)

  • Singly Linked List: Memory layout vs. Contiguous Arrays.
  • Reverse a Linked List: Walked through the in-place 3-pointer iterative reversal (prev, curr, next) in $O(N)$ time and $O(1)$ space.

5. Questions for Interviewer

  • Asked about his team's tech stack and engineering architecture.
  • Asked how technical decision-making and architecture evolve across a 12-year tenure at GEP.

Round 3: HR Discussion (10 Minutes)

  • Family background and educational journey.
  • Confirmation of relocation preferences and readiness for the 2-month summer internship duration.
  • Document and identity verification check.

Key Takeaways

  1. Be Decisive When You Don't Know: During rapid-fire rounds, guessing wastes time and hurts credibility. If you don't know a concept, say so within 2 seconds. Senior engineers value honesty over guessing.
  2. Practice Plain-Text Coding: Practice coding without IDE autocompletion or compiler error messages. Writing clean code in Notepad reveals whether your syntax and pointer mechanics are intuitive.
  3. Know Your Resume Boundaries: If you have specialized domains like AI/ML on your resume, clearly delineate between foundational theory and applied engineering to keep the conversation within your strengths.
  4. Learn STL Under-the-Hood: Along with standard algorithmic techniques (two-pointer, sliding window), know the corresponding STL implementations (e.g., std::unique, std::lower_bound).
  5. Composure: Getting nervous is normal, but do not let it accelerate your speech. Take a one-second pause before speaking, structure your answer chronologically, and treat the interview as a collaborative engineering discussion.

Questions asked (2)

  1. 01

    Missing Number

    Data Structures & Algorithms · Easy

    Given an array of size n-1 containing numbers from 1 to n, find the single missing number.

    Open the problem
  2. 02

    Remove Duplicates from Sorted Array

    Data Structures & Algorithms · Easy

    Given a sorted vector containing duplicates (e.g., [1, 1, 1, 2, 2, 3, 3]), modify it in-place so each element appears only once.

    Open the problem

Know someone preparing? Send it to them:WhatsAppLinkedInX

Interviewed at Gep Worldwide recently?

Write up your rounds while you still remember the questions. It helps the next person more than you would think.

Share your experience
Discussion 0

Questions for the author, or how your own interview compared.

Join the discussion

Sign in with Google to comment or ask the author a question.

No comments yet

Be the first to share your thoughts and start the discussion!