Slice SDE-1: 2021 Campus Questions and Rounds

The source and its time boundary

The source is Modabbir Tarique's first-person Medium post, "My Journey to Slice." He identifies himself as an IIT Guwahati Chemical Engineering student and says that Slice visited his campus for an SDE-1 role during the 2021 placement period. The post was published in January 2022. Its value is the detailed sequence and named questions, not proof of a current company-wide process.

The post states that this drive used CGPA 7.00 and was open to all B.Tech branches at the resume-shortlisting stage. The author's broader advice about maintaining CPI at that level reflects his campus experience and should not be converted into a current Slice rule. The source does not disclose compensation, so this article does not supply or estimate it.

The online test had 15 aptitude questions and two coding questions. The first described information spreading through an N-ary company hierarchy, with information moving from a parent to a child. The second linked directly to Codeforces problem 1133/C. Practising these tasks is useful for the skills they exercise, but the source does not say that they will recur in another Slice test.

The author reports that 3 of 6 candidates in his group moved past the first interview, and that he alone moved past the next interview. Those are raw counts from one group. They do not establish an overall selection rate, cutoff, or difficulty level. He describes a roughly 15-minute HR conversation and remembers receiving the selection call about 30 minutes later. That timing is a personal recollection, not a service-level promise for another candidate.

Round-by-round breakdown: questions, format, conversion

Here is the candidate-reported structure in one table. It describes only the author's group and sequence.

Round 1 included maximum-sum path questions on binary trees. A defensible preparation approach is to define what a path may include, clarify whether endpoints must be leaves, handle all-negative values, separate a downward contribution from a complete path, and explain the traversal and state. Do not attach a made-up completion-time target to the task.

The second technical round, which the author says was conducted by a director, included a three-table SQL join, pizza-billing design, project questions, and probability questions. For the SQL task, practise stating table keys, join conditions, duplicate behaviour, and missing relationships. For the design task, clarify supported sizes and toppings, represent pricing rules, validate requests, and keep calculation logic testable. These are preparation deductions from the reported prompts, not extra Slice requirements.

What a complete answer should expose

For the N-ary information task, clarify whether a person can inform one child or several children at a time, whether each transfer has the same cost, and whether child order can be chosen. Those details determine the recurrence. Draw a small hierarchy, state the scheduling rule, and trace when each subtree finishes. Do not assume a parallelism rule merely because the story uses employees.

For the binary-tree path tasks, distinguish a path that may start and end anywhere from one whose endpoints must be leaves. Decide what each recursive call returns and what can update the overall answer. Explain how the solution behaves when node values are adverse or a node has only one child. This makes the two reported prompts meaningfully different.

For the three-table join, state table keys before writing SQL. Explain whether unmatched rows should remain, whether duplicates are legitimate, and how aggregation changes the result. Run the query against a tiny hand-built example that includes a missing relationship and more than one matching row.

For pizza billing, keep price rules separate from presentation. Define how a size and topping selection is validated, how the calculation receives catalogue prices, and how a bill records the applied rule. If discounts, tax, or currency are not in the prompt, ask instead of inventing them.

Preparation derived from the reported work

Use this account to select skills, then use the current job listing to set scope. Progress should be measured by whether you can solve, explain, test, and revise a task, not by an arbitrary calendar or problem quota.

Verify eligibility and make the resume defensible

• Read the current role or campus notice. Do not reuse the 2021 drive's CGPA rule without confirmation.
• For every project, identify your contribution, decisions, tests, observed result, limitations, and what you would change.
• Remove impact numbers you cannot support. A smaller truthful result is stronger than a fabricated metric.

Rehearse the reported coding concepts

• Solve binary-tree path problems until you can explain the state returned by recursion and the state used for the global answer.
• Solve the specific N-ary tree information-propagation problem and Codeforces 1133/C as listed in the account. Both are public problems with editorial solutions.
• After solving, test empty, minimal, skewed, duplicate, and adverse-value cases where the problem contract allows them. State complexity from the implementation you actually wrote.

Practise SQL and small-system design

• Practice writing actual 3-table join queries in MySQL or PostgreSQL, not pseudo-SQL on a whiteboard. Round 2 included a 3-table join, and the interviewer was a Director.
• For pizza billing, clarify inputs and rules before choosing entities or classes. Separate catalogue data from an order, represent selected options, validate unsupported combinations, and make the calculation auditable.
• The account says Round 2 included probability questions but does not name the subtopics. Use the current role or assessment scope to choose which probability concepts to review.

Rehearse explanation and truthful examples

• Practise solving without an IDE because the author reports writing in a shared document. Explain assumptions and test cases before declaring the solution complete.
• Prepare a concise account of your background, interests, and reason for the specific current role. Tie it to official role information rather than a generic company pitch.
• Rehearse project follow-ups with someone who can challenge your personal contribution and technical trade-offs.

Common mistakes and red flags

• Ignoring a disclosed assessment section. The historical test included 15 aptitude questions, but the source gives no cutoff or topic list.
• Pseudo-SQL instead of executable reasoning. Round 2 reportedly asked a 3-table join. State keys and join semantics, then write syntax consistent with the chosen database.
• Adding requirements to the design. Do not introduce distributed infrastructure, discounts, or scale unless the prompt supplies a need.
• Vague project descriptions. Both technical rounds included project follow-ups. Explain your own architecture, data flow, tests, and trade-offs truthfully.
• Ignoring source age. The account describes a 2021 campus process and cannot establish current eligibility or rounds.

Real-world data points

• Reported CGPA eligibility: 7.00, all B.Tech branches, for the author's 2021 campus drive.
• Online test structure: 15 aptitude MCQs + 2 coding questions (candidate-reported).
• Round 1 duration: 45 minutes (candidate-reported).
• Round 1 conversion: 3 of 6 candidates cleared (candidate-reported).
• Round 2 conversion: 1 candidate selected, the author (candidate-reported).
• Round 3 (HR) duration: roughly 15 minutes (candidate-reported).
• Offer notification time: roughly 30 minutes after the final round (candidate-reported).
• CTC: not disclosed in the source account.

Sources & credits

• https://medium.com/@modabbirtarique/my-journey-to-slice-from-non-cse-background-62964df0528e