CGI Group Interview Questions 2026 (with Answers for Freshers)

Last Updated: March 2026

---

Introduction

CGI (Conseillers en Gestion et Informatique) is one of the largest IT and business consulting services firms in the world. Founded in 1976 in Quebec, Canada, CGI operates in 400+ locations across 40 countries with approximately 90,000 employees. The company offers a comprehensive portfolio of services including consulting, systems integration, IT outsourcing, and business process services.

CGI is known for its unique member ownership model, where professionals become shareholders after a qualifying period, fostering a culture of ownership and long-term commitment. The company serves clients across multiple industries including financial services, government, healthcare, telecommunications, and manufacturing.

For freshers, CGI offers excellent opportunities through its structured training programs, global career mobility, and a culture that emphasizes professional development and work-life balance.

---

CGI Selection Process 2026

Stage	Description	Duration
Round 1: Online Assessment	Aptitude, Logical, Verbal, Technical MCQs	60-90 minutes
Round 2: Technical Interview	Core subjects, Coding, Project discussion	30-45 minutes
Round 3: HR Interview	Behavioral, Communication, Culture fit	20-30 minutes

Eligibility Criteria:

• Minimum 60-65% throughout academics
• No active backlogs
• CS/IT/MCA/ECE preferred

---

HR Interview Questions and Answers

1. Tell me about yourself.

---

2. Why do you want to join CGI?

---

3. What do you know about CGI's business model?

1. Consulting Services: Strategic advisory, business transformation, and change management
2. Systems Integration and Consulting: Application development, modernization, and integration services
3. Managed IT and Business Process Services: IT outsourcing, infrastructure management, and BPO services

CGI follows a local proximity model, maintaining offices close to clients for better service delivery. The company serves both private and public sector clients, with significant presence in government, financial services, and healthcare. CGI's unique member-ownership model creates alignment between employees and shareholders, fostering long-term client relationships. The company also invests in proprietary solutions and frameworks to accelerate project delivery."

---

4. What are your strengths and weaknesses?

As for weaknesses, I sometimes find it difficult to delegate tasks when I am passionate about a project, wanting to ensure everything is done perfectly. I am working on this by recognizing that trust in teammates and proper delegation leads to better outcomes. I have learned to focus on oversight and guidance rather than doing everything myself."

---

5. Where do you see yourself in 5 years?

---

6. How do you handle stress at work?

I also believe in open communication with my team and manager when facing tight deadlines or obstacles. During my internship, I successfully managed a high-pressure situation by staying calm, focusing on solutions, and collaborating with teammates. This experience taught me that stress is manageable with the right approach and support system."

---

7. Are you willing to relocate or travel?

---

8. What motivates you?

---

9. How do you prioritize your work?

1. Urgent and Important: Critical deadlines, production issues - do these first
2. Important but Not Urgent: Strategic work, skill development - schedule these
3. Urgent but Not Important: Delegate if possible
4. Neither Urgent nor Important: Eliminate or minimize

I also communicate with stakeholders to understand business priorities and adjust accordingly. Daily stand-ups and weekly planning sessions help me stay aligned with team goals. I use project management tools to track progress and ensure nothing falls through the cracks."

---

10. Do you have any questions for us?

1. Could you tell me more about the training and onboarding process for new graduates at CGI?
2. What does the typical career progression path look like for someone starting in this role?
3. How does CGI support continuous learning and professional development?
4. Could you describe the team culture and collaboration practices?
5. What are the opportunities for global mobility and working on international projects?
6. How does CGI's member ownership model work for employees?"

---

Technical Interview Questions and Answers

1. Explain the difference between Arrays and Linked Lists.

Feature	Array	Linked List
Memory	Contiguous	Non-contiguous
Size	Fixed (static arrays) or amortized (dynamic)	Dynamic
Access	O(1) - Random access	O(n) - Sequential access
Insertion	O(n) - Shifting required	O(1) at head, O(n) at arbitrary position
Deletion	O(n) - Shifting required	O(1) with reference, O(n) otherwise
Memory Overhead	Low	High (extra pointer per node)
Cache Performance	Good (locality of reference)	Poor

When to use Array:

• Frequent random access needed
• Memory efficiency is important
• Size is known or changes infrequently

When to use Linked List:

• Frequent insertions/deletions
• Size changes dynamically
• Implementing queues, stacks, or adjacency lists

---

2. Write a program to check if two strings are anagrams.

Python Solution:

def are_anagrams(s1, s2):
    """
    Returns True if strings are anagrams, False otherwise
    """
    # Remove spaces and convert to lowercase
    s1 = s1.replace(" ", "").lower()
    s2 = s2.replace(" ", "").lower()
    
    # Quick length check
    if len(s1) != len(s2):
        return False
    
    # Method 1: Using sorted
    return sorted(s1) == sorted(s2)

def are_anagrams_counter(s1, s2):
    """
    More efficient approach using character counting
    """
    from collections import Counter
    
    s1 = s1.replace(" ", "").lower()
    s2 = s2.replace(" ", "").lower()
    
    return Counter(s1) == Counter(s2)

# Test
print(are_anagrams("listen", "silent"))      # True
print(are_anagrams("hello", "world"))        # False
print(are_anagrams("Dormitory", "Dirty room"))  # True

Time Complexity:

• Sorted method: O(n log n)
• Counter method: O(n)

Space Complexity: O(n) or O(1) if assuming fixed character set

---

3. What is the difference between INNER JOIN and OUTER JOIN?

Table Structure:

-- Employees table
| emp_id | emp_name | dept_id |
|--------|----------|---------|
| 1      | John     | 1       |
| 2      | Jane     | 2       |
| 3      | Bob      | NULL    |
| 4      | Alice    | 3       |

-- Departments table
| dept_id | dept_name |
|---------|-----------|
| 1       | IT        |
| 2       | HR        |
| 5       | Finance   |

INNER JOIN:

SELECT e.emp_name, d.dept_name
FROM Employees e
INNER JOIN Departments d ON e.dept_id = d.dept_id;

-- Result: Only matching rows
| emp_name | dept_name |
|----------|-----------|
| John     | IT        |
| Jane     | HR        |

LEFT OUTER JOIN:

SELECT e.emp_name, d.dept_name
FROM Employees e
LEFT JOIN Departments d ON e.dept_id = d.dept_id;

-- Result: All employees, matching departments
| emp_name | dept_name |
|----------|-----------|
| John     | IT        |
| Jane     | HR        |
| Bob      | NULL      |
| Alice    | NULL      |

RIGHT OUTER JOIN:

SELECT e.emp_name, d.dept_name
FROM Employees e
RIGHT JOIN Departments d ON e.dept_id = d.dept_id;

-- Result: Matching employees, all departments
| emp_name | dept_name |
|----------|-----------|
| John     | IT        |
| Jane     | HR        |
| NULL     | Finance   |

FULL OUTER JOIN:

SELECT e.emp_name, d.dept_name
FROM Employees e
FULL OUTER JOIN Departments d ON e.dept_id = d.dept_id;

-- Result: All records from both tables

---

4. Write a program to find the longest substring without repeating characters.

Sliding Window Approach (Optimal):

def longest_substring_without_repeating(s):
    """
    Returns the length of the longest substring without repeating characters
    """
    char_index = {}  # Stores last seen index of each character
    max_length = 0
    start = 0  # Start of current window
    
    for end, char in enumerate(s):
        # If character seen before and is in current window
        if char in char_index and char_index[char] >= start:
            # Move start to exclude the previous occurrence
            start = char_index[char] + 1
        
        # Update last seen index
        char_index[char] = end
        
        # Update max length
        max_length = max(max_length, end - start + 1)
    
    return max_length

# Also return the substring
def longest_substring_with_result(s):
    char_index = {}
    max_length = 0
    max_start = 0
    start = 0
    
    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        
        char_index[char] = end
        
        if end - start + 1 > max_length:
            max_length = end - start + 1
            max_start = start
    
    return s[max_start:max_start + max_length], max_length

# Test
print(longest_substring_without_repeating("abcabcbb"))  # 3 ("abc")
print(longest_substring_without_repeating("bbbbb"))     # 1 ("b")
print(longest_substring_without_repeating("pwwkew"))    # 3 ("wke")

Time Complexity: O(n) - single pass Space Complexity: O(min(m, n)) where m is charset size

---

5. Explain the difference between Compilation and Interpretation.

Feature	Compiled Languages	Interpreted Languages
Translation	Entire program translated to machine code at once	Line-by-line translation during execution
Execution Speed	Faster (direct machine code execution)	Slower (translation overhead)
Development Speed	Slower (compilation step required)	Faster (no compilation)
Error Detection	All errors detected at compile time	Errors detected at runtime
Portability	Platform-specific (needs recompilation)	More portable (needs interpreter)
Memory Usage	Lower (executes compiled code)	Higher (interpreter required)
Examples	C, C++, Rust, Go	Python, JavaScript, Ruby

How Compilation Works:

Source Code (.c) -> Compiler -> Machine Code (.exe) -> CPU Execution

How Interpretation Works:

Source Code -> Interpreter -> Immediate Execution
(Line by line translation)

Java - Hybrid Approach:

Source Code (.java) -> Compiler -> Bytecode (.class) -> JVM -> Machine Code

Python - Interpreted with Compilation:

Source Code (.py) -> Compiled to Bytecode (.pyc) -> Python VM -> Execution

---

6. Write a program to implement Merge Sort.

Python Implementation:

def merge_sort(arr):
    """
    Sorts array using merge sort algorithm
    Time Complexity: O(n log n)
    Space Complexity: O(n)
    """
    if len(arr) <= 1:
        return arr
    
    # Divide
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    # Conquer (Merge)
    return merge(left, right)

def merge(left, right):
    """Merges two sorted arrays"""
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    # Add remaining elements
    result.extend(left[i:])
    result.extend(right[j:])
    
    return result

# In-place version (more space efficient)
def merge_sort_inplace(arr, left=0, right=None):
    if right is None:
        right = len(arr) - 1
    
    if left < right:
        mid = (left + right) // 2
        merge_sort_inplace(arr, left, mid)
        merge_sort_inplace(arr, mid + 1, right)
        merge_inplace(arr, left, mid, right)

def merge_inplace(arr, left, mid, right):
    """In-place merge using temporary array"""
    # Create temporary arrays
    left_arr = arr[left:mid + 1]
    right_arr = arr[mid + 1:right + 1]
    
    i = j = 0
    k = left
    
    while i < len(left_arr) and j < len(right_arr):
        if left_arr[i] <= right_arr[j]:
            arr[k] = left_arr[i]
            i += 1
        else:
            arr[k] = right_arr[j]
            j += 1
        k += 1
    
    while i < len(left_arr):
        arr[k] = left_arr[i]
        i += 1
        k += 1
    
    while j < len(right_arr):
        arr[k] = right_arr[j]
        j += 1
        k += 1

# Test
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = merge_sort(arr)
print(f"Sorted array: {sorted_arr}")

---

7. What is the difference between Primary Key and Unique Key?

Feature	Primary Key	Unique Key
Null Values	Cannot contain NULL	Can contain one NULL (in most databases)
Number per Table	Only one	Multiple allowed
Purpose	Uniquely identifies each record	Ensures uniqueness of column(s)
Clustered Index	Creates clustered index by default	Creates non-clustered index
Auto-increment	Often used with auto-increment	Not auto-increment

SQL Examples:

-- Primary Key
CREATE TABLE Students (
    student_id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL
);

-- Unique Key
CREATE TABLE Employees (
    emp_id INT PRIMARY KEY,
    email VARCHAR(100) UNIQUE,  -- Cannot have duplicate emails
    phone VARCHAR(20) UNIQUE,   -- Cannot have duplicate phones
    name VARCHAR(100)
);

-- Composite Primary Key
CREATE TABLE Enrollments (
    student_id INT,
    course_id INT,
    enrollment_date DATE,
    PRIMARY KEY (student_id, course_id)  -- Composite key
);

---

8. Write a program to find the first non-repeating character in a string.

def first_non_repeating(s):
    """
    Returns the first non-repeating character in a string
    Returns None if all characters repeat
    """
    from collections import OrderedDict
    
    # Count character occurrences
    char_count = OrderedDict()
    
    for char in s:
        char_count[char] = char_count.get(char, 0) + 1
    
    # Find first character with count 1
    for char, count in char_count.items():
        if count == 1:
            return char
    
    return None

def first_non_repeating_index(s):
    """
    Returns index of first non-repeating character
    """
    char_count = {}
    
    # First pass: count occurrences
    for char in s:
        char_count[char] = char_count.get(char, 0) + 1
    
    # Second pass: find first non-repeating
    for i, char in enumerate(s):
        if char_count[char] == 1:
            return i
    
    return -1

# Test
print(first_non_repeating("swiss"))        # 'w'
print(first_non_repeating("hello"))        # 'h'
print(first_non_repeating("aabbcc"))       # None
print(first_non_repeating_index("loveleetcode"))  # 2 ('v')

Time Complexity: O(n) Space Complexity: O(k) where k is character set size

---

9. Explain the difference between Multi-threading and Multi-processing.

Feature	Multi-threading	Multi-processing
Definition	Multiple threads within same process	Multiple processes running concurrently
Memory	Shares memory space	Separate memory space
Communication	Easy (shared memory)	Complex (IPC needed)
Overhead	Low	High
Fault Isolation	Low (one thread crash affects all)	High (processes are isolated)
GIL (Python)	Limited by GIL	Bypasses GIL
Use Case	I/O bound tasks	CPU bound tasks
Creation Cost	Low	High

Python Example:

import threading
import multiprocessing
import time

# Multi-threading (for I/O bound tasks)
def io_task(url):
    # Simulate network request
    time.sleep(1)
    print(f"Downloaded {url}")

threads = []
for url in ["url1", "url2", "url3"]:
    t = threading.Thread(target=io_task, args=(url,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

# Multi-processing (for CPU bound tasks)
def cpu_task(n):
    # Heavy computation
    return sum(i * i for i in range(n))

if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(cpu_task, [1000000, 2000000, 3000000])

When to use:

• Threading: Network operations, file I/O, user interface
• Processing: Data processing, mathematical computations, image processing

---

10. Write a SQL query to find the department with the highest average salary.

-- Method 1: Using ORDER BY and LIMIT
SELECT department, AVG(salary) as avg_salary
FROM Employees
GROUP BY department
ORDER BY avg_salary DESC
LIMIT 1;

-- Method 2: Using subquery with MAX
SELECT department, AVG(salary) as avg_salary
FROM Employees
GROUP BY department
HAVING AVG(salary) = (
    SELECT MAX(avg_sal)
    FROM (
        SELECT AVG(salary) as avg_sal
        FROM Employees
        GROUP BY department
    ) as dept_avg
);

-- Method 3: Using window functions (ranking)
WITH DeptAvg AS (
    SELECT department, 
           AVG(salary) as avg_salary,
           RANK() OVER (ORDER BY AVG(salary) DESC) as rank
    FROM Employees
    GROUP BY department
)
SELECT department, avg_salary
FROM DeptAvg
WHERE rank = 1;

-- Method 4: If multiple departments tie for highest
WITH DeptAvg AS (
    SELECT department, AVG(salary) as avg_salary
    FROM Employees
    GROUP BY department
)
SELECT department, avg_salary
FROM DeptAvg
WHERE avg_salary = (SELECT MAX(avg_salary) FROM DeptAvg);

---

Behavioral Interview Questions and Answers (STAR Format)

1. Describe a time when you had to work with a difficult team member.

Situation: In a group project for my Database Management Systems course, one team member was consistently missing meetings and submitting work late, which was affecting our project timeline.

Task: As the team coordinator, I needed to address this issue without creating conflict and ensure we delivered the project on time.

Action:

• Had a private conversation to understand if there were any underlying issues (found he was struggling with personal commitments)
• Redistributed tasks based on his available time slots
• Set up shorter, more frequent check-ins instead of long meetings
• Paired him with another teammate for peer support
• Established clear expectations and deadlines

Result: The team member's performance improved significantly, and we submitted the project two days early with excellent marks. He later thanked me for being understanding rather than confrontational. I learned that empathy and flexibility often yield better results than rigid enforcement.

---

2. Tell me about a time when you took initiative.

Situation: During my internship, I noticed that the QA team was spending hours manually testing API endpoints before each release.

Task: I saw an opportunity to automate this process to save time and improve reliability.

Action:

• Researched API testing tools and proposed using Postman for automated testing
• Created a collection of automated tests covering all major endpoints
• Set up Newman (Postman's CLI tool) for CI/CD integration
• Documented the testing process and trained team members
• Presented the solution to my manager with time-saving projections

Result: The automation reduced testing time from 4 hours to 30 minutes per release. My manager implemented it across the team, and I received recognition during the quarterly review. The experience taught me the value of identifying inefficiencies and proactively proposing solutions.

---

3. Give an example of how you handled a tight deadline.

Situation: Two days before my final project submission, we discovered a critical bug in our application's payment gateway integration that would cause transaction failures.

Task: I needed to fix the bug while completing documentation and preparing for the presentation.

Action:

• Immediately assembled the team to assess the situation
• Prioritized tasks: bug fix (critical), core documentation (required), presentation enhancements (optional)
• Set up pair programming to speed up debugging and ensure quality
• Worked in focused sprints with regular status checks
• Communicated proactively with our advisor about the situation

Result: We fixed the bug within 8 hours and submitted a fully functional project on time. Our advisor commended our crisis management and the quality of our final deliverable. The experience reinforced my ability to remain calm and effective under pressure.

---

4. Describe a situation where you had to learn something outside your comfort zone.

Situation: For my capstone project, I needed to implement a recommendation system, which required machine learning knowledge I didn't have.

Task: I had to learn machine learning fundamentals and implement a working recommendation engine within six weeks.

Action:

• Created a structured learning plan: ML basics (2 weeks), collaborative filtering (2 weeks), implementation (2 weeks)
• Completed Andrew Ng's Machine Learning course on Coursera
• Read research papers on recommendation algorithms
• Implemented progressively complex prototypes
• Consulted with a professor who specialized in ML

Result: I successfully built a hybrid recommendation system using collaborative and content-based filtering, achieving 85% accuracy in predictions. The project received the highest grade in the cohort, and I discovered a passion for data science that I'm now pursuing further. This experience taught me that stepping outside my comfort zone leads to significant growth.

---

5. Tell me about a time when you received feedback and acted on it.

Situation: During my first performance review at my internship, my manager noted that while my technical skills were strong, my communication in team meetings could be more concise and structured.

Task: I needed to improve my communication effectiveness without losing technical depth.

Action:

• Asked for specific examples and clarification on what "more concise" meant
• Studied effective presentation techniques and the PREP method (Point, Reason, Example, Point)
• Started preparing brief talking points before meetings
• Practiced active listening and summarizing key points
• Recorded myself presenting to identify filler words and rambling

Result: Within a month, my manager commented on the noticeable improvement. I became more confident in meetings and was asked to present my project to senior leadership. I learned that constructive feedback is a growth opportunity and that communication skills are as important as technical skills.

---

CGI-Specific Interview Tips

1. Understand the Ownership Culture

CGI's member ownership model is unique. Show that you understand and value long-term commitment and ownership mindset.

2. Research CGI's Industry Focus

CGI has strong presence in government, financial services, and healthcare. Understand the IT challenges in these sectors.

3. Prepare for Consulting Scenarios

CGI is a consulting firm. Practice case studies and client interaction scenarios.

4. Show Interest in Long-term Growth

CGI values professionals who want to build careers, not just jobs. Express interest in long-term development.

5. Understand Local Proximity Model

CGI emphasizes being close to clients. Be open to working at client locations when needed.

6. Focus on Professionalism

CGI has a professional, corporate culture. Dress appropriately and maintain professional demeanor.

7. Demonstrate Flexibility

Consulting requires adaptability. Show examples of how you've adapted to new situations.

8. Research CGI's Values

CGI emphasizes integrity, quality, and client success. Align your answers with these values.

9. Prepare for Behavioral Questions

CGI places high importance on cultural fit. Have multiple STAR-format examples ready.

10. Ask About Member Program

Show interest in CGI's unique ownership model by asking about the member shareholder program.

---

Frequently Asked Questions (FAQs)

1. What is the salary for freshers at CGI in 2026?

2. How long is the training period at CGI?

3. Does CGI have a service agreement?

4. What is CGI's member ownership program?

5. How can I prepare for CGI's online test?

---

Conclusion

CGI interviews require a combination of solid technical skills, understanding of consulting culture, and alignment with the company's ownership values. Focus on demonstrating your technical competence while showing that you understand and appreciate CGI's unique culture.

Remember that CGI looks for professionals who want to build long-term careers and take ownership of their work. Show your commitment to continuous learning, client success, and professional growth.

Best of luck with your CGI interview!

---

Related Articles:

• CGI Group Placement Papers 2026
• Consulting Interview Guide
• Behavioral Interview Preparation