Jupiter SDET Intern: 2023 Interview Questions

The candidate-reported Jupiter SDET interview journey

The interview experience we are grounding in comes from a single candidate-reported account published on GeeksforGeeks on 22 May 2023, for an SDET Intern role at Jupiter (Jupiter Money). The placement was an on-campus drive, meaning Jupiter's recruitment team visited the candidate's college to conduct the selection process. As with any single interview experience, this represents one data point from one cycle, and the actual process in 2026 may have changed.

The process ran three reported rounds. Round 1 was an online coding round containing three programming problems. This was followed by two technical interviews. The candidate reported receiving an offer letter at the end, but did not state the elapsed time between the final interview and that result.

An SDET role blends software-development and test-engineering work, so coding fluency and deliberate edge-case analysis are relevant preparation areas. This account reported only programming questions and did not mention testing theory, an automation framework, or a financial-domain scenario. Do not infer Jupiter's current role scope or interview rubric beyond what the source records.

The standout problem in the coding round was "Parallel Sums." Given [16, 22, 35, 8, 20, 1, 21, 11], the source's expected output separates the values as [1, 11, 20, 35] and [8, 16, 21, 22]. Each group contains four values and sums to 67. A sound first check is whether an equal-size split is possible and whether the total can be divided equally. Backtracking can then build a group with the required size and target sum while preserving the output-order rule stated in the prompt.

The first interview round, as reported by the candidate, covered Two Sum and finding the first and last occurrence of a specific element. These problems exercise hash-map or two-pointer reasoning, input-order awareness, and the choice between a linear scan and binary search. Their presence establishes what this candidate faced, not a guaranteed Jupiter question bank.

The second interview round shifted to matrix problems. The candidate was asked to compute the primary and secondary diagonal sums of a square matrix and to generate a spiral matrix. These tasks exercise index management, boundary checks, direction changes, and careful treatment of the centre cell in an odd-sized matrix.

Round-by-round breakdown and question pattern

Based on the GeeksforGeeks account, here is the structured breakdown of what the candidate faced across all three rounds. Every detail below is candidate-reported from the source published 22 May 2023.

The disclosed question set was weighted toward arrays and matrices. The source did not report questions on trees, graphs, linked lists, or system design, but silence in one account is not proof that those topics never appear. Use the named problems for focused practice without treating them as a complete current syllabus.

Parallel Sums adds both a target-sum and an equal-size constraint. A backtracking or dynamic-programming solution can represent those constraints explicitly. For the other reported array and matrix tasks, practise stating the contract, tracing an example, testing boundaries, and explaining complexity. The source does not establish a difficulty ranking or fixed follow-up script.

For the Parallel Sums problem specifically, here is the approach a well-prepared candidate would take. First, check if the array length is even (if not, equal-size partitioning is impossible). Second, compute the total sum and check if it is divisible by 2. Third, use backtracking to try including each element in group A or group B, pruning branches where the current group size exceeds n/2 or the running sum exceeds the target. The time complexity is exponential in the worst case, but pruning makes it practical for small inputs. An alternative approach uses dynamic programming with a state of (index, size_of_group_A, sum_of_group_A), reducing the problem to a 3D DP that runs in O(n * n/2 * target_sum) time.

For the matrix diagonal-sum problem, the primary diagonal contains positions where the row and column indices match, while the secondary diagonal contains positions whose indices sum to one less than the dimension. In an odd-sized square matrix, the centre belongs to both. Ask whether the contract counts it once or twice instead of assuming a convention.

Prep playbook grounded in the reported questions

If you are targeting a Jupiter SDET intern role, organise preparation by the skill gaps exposed in this account. Adjust the order to your own baseline and follow the current role description when it differs.

Array fundamentals. Practise traversal, minimum and maximum values, reversal, rotation, and hash-map lookup. Two Sum maps directly to the reported first interview. Related array exercises are useful for transfer, but are not claimed as Jupiter questions.

Searching and occurrence problems. The candidate reported being asked about the first and last occurrence of an element. Practise binary-search variants and be ready to explain when a linear scan is required because the input is not sorted.

Matrix operations. Practise row-major and column-major traversal, diagonal sums, spiral traversal, spiral generation, and matrix rotation. Write a solution without editor assistance, then explain the loop invariants and boundary updates aloud.

Backtracking and partition problems. Parallel Sums adds an equal-size constraint to an equal-sum partition task. Practise defining state, base cases, and pruning conditions, then test whether your approach preserves both the target sum and the required group size.

Mock interviews and SDET-specific preparation. Add test-case design, edge-case identification, automation-framework basics, and API-testing concepts. For each solution, cover ordinary inputs, boundaries, empty input when permitted, repeated values, and invalid input according to the stated contract.

Maintain an error log that records failed assumptions, missed boundaries, and complexity mistakes. Revisit unresolved problems until you can explain the correction without relying on memorised code.

Common mistakes and red flags to avoid

Based on the reported problems, these are the errors worth testing explicitly:

• Ignoring an absent target. For an occurrence-finding problem, ask what output the contract requires when the target is missing. Do not assume a sentinel pair unless the prompt defines it.

• Not clarifying odd-sized diagonal sums. The centre belongs to both diagonals. If the contract wants every cell counted once, subtract one copy; if it wants two diagonal totals, follow that wording.

• Assuming a greedy split is sufficient. Sorting and pairing values from the ends is not guaranteed to satisfy both equal size and equal sum. Backtracking or a state that tracks index, selected count, and sum can enforce both constraints.

• Poor complexity analysis. State what each variable represents and justify time and auxiliary-space bounds from the loops, recursion, and stored state.

• No test-case thinking. For an SDET role, demonstrate how you would test boundaries and invalid states after confirming the prompt's input contract.

Real-world data points

• 3 total rounds in the candidate-reported Jupiter SDET intern process (1 coding + 2 interviews), as posted on GeeksforGeeks on 22 May 2023.
• 3 problems in the online coding round, with Parallel Sums as the standout question.
• 8 elements in the Parallel Sums worked example: [16, 22, 35, 8, 20, 1, 21, 11], each group requiring 4 elements.
• 2 problems in Interview Round 1: Two Sum and first/last occurrence of an element.
• 2 problems in Interview Round 2: matrix diagonal sums and spiral matrix generation.
• 0 problems reported on trees, graphs, dynamic programming, or system design across all rounds.
• 0 disclosed details on CTC, round duration, or eligibility criteria in the source account.
• 1 offer letter reported as received at the end of the process.

Sources & credits

• https://www.geeksforgeeks.org/jupiter-money-interview-experience-for-sdet/