Bending Spoons Assessment: Unfamiliar Problems, Role Tasks, and Preparation Boundaries

You receive a Bending Spoons task invitation and find descriptions of logic tests, long assignments, and technical interviews online. The useful next step is not to assemble those descriptions into one imagined exam. Identify the employer's published claims, the scope of each applicant's report, and the requirements in your own invitation.

Use that evidence check alongside an original rule-comprehension exercise. For another way to practice learning a new rule system, try PracHub’s three-card game task, where adding a category changes the implementation contract. Neither exercise is represented as a reported Bending Spoons question.

Evidence boundary: official employer materials were checked on October 13, 2026. Two independent candidate posts are dated April 7 and July 23, 2026, but concern different roles and stages; they do not establish a matching intake or a universal assessment format. Preparation suggestions are our inferences. The crate exercise is original practice with 38 passing Python checks, not leaked material, an employer simulator, or a predictor of selection.

What does Bending Spoons actually publish?

Official facts: the application-process PDF presents a general framework that can vary by job. It describes screening, tests or tasks, and interviews. The tasks may assess unfamiliar problem solving, job expertise, and behavioral qualities. It directs candidates to the instructions for the declared evaluation and to their recruiter when something is unclear.

Official role example: the current Graduate software engineer vacancy describes one or more challenging tests after screening, potentially involving unfamiliar problems and several hours of work. This is a workload warning, not a published per-question timer, fixed three-hour paper, or guarantee of identical tasks for every role.

Official preparation boundary: the careers FAQ says no interview preparation is needed unless the candidate support manager provides specific preparation information. That statement concerns interview guidance. Our optional exercises below are not a company requirement or a claim that purchasing a preparation pack is necessary.

Read candidate reports at their actual scope

Candidate report: in the April product-management discussion, the author anticipated further rounds and later edited the post to say they had not cleared the tests. Anticipation is not proof that those later rounds occurred; the edit’s outcome date was not established by the original publication timestamp.

Candidate report: the July graduate AI engineering discussion asks what the upcoming system-design component might contain. Its references to LLMs or recommendations are questions, not confirmed delivered tasks. We verified the absolute posting dates in the live page rather than converting a cached “months ago” label into an exact date.

Inference: these accounts justify taking role and stage differences seriously. They do not justify combining product-management reasoning, a graduate AI interview, and an anonymous commenter’s timing into one mandatory sequence. No same-role, same-cycle matching pair was verified here, so this guide centers the official framework and labels the anecdotes separately.

Turn the invitation into an operational checklist

Start by locating the position, current stage, task names, deadline and time zone, expected deliverable, and any active timer. Distinguish “submit by Friday” from “complete within a timed session after starting.” If the invitation does not resolve that distinction, ask the named contact before beginning the timed portion.

Check whether tasks can be separated, whether pausing is possible, and what happens if the platform fails. Record permitted materials and tools, including whether external assistance, AI, calculators, documentation, or a particular development environment are allowed. These are questions to resolve from the invitation, not permissions this article can grant.

An employer’s use of AI at work does not, by itself, establish an assessment’s assistance rules. Equally, a Reddit comment does not establish the policy for your invitation. Keep original practice outside the live assessment and follow its stated conditions. We do not supply protected tasks or recommend reproducing another applicant’s answers.

Official support route: the careers FAQ provides an accommodations process and says requesting accommodations does not affect the application outcome. Use that route when appropriate, rather than changing task conditions yourself. Practical arrangements and access questions can be resolved without sharing private assessment content in a public discussion.

Practice extracting a new rule system

Here is our original four-crate exercise. It trains careful interpretation without pretending to reproduce the company’s assessment. Four crates labeled A, B, C, and D appear exactly once in a left-to-right row. Alphabetical order is A before B before C before D. Apply these two operations in the stated order:

1. Seal: compare the current first and last labels. If the first comes earlier alphabetically, swap those two crates. Otherwise, leave the row unchanged.
2. Lift: find B in the row after Seal. If B is not first, swap it with the crate immediately to its left. If B is already first, do nothing.

Apply Seal once, then Lift once. Each operation reads the current state when that operation begins. There is no repetition until stable, no sorting of the entire row, no wrap from first to last, and no simultaneous evaluation from the original row. Those exclusions are part of this practice specification.

Before solving, restate the input domain and the two conditional branches. Write one intermediate row between the operations. The goal is to expose the interpretation, not to guess a pattern from examples. If a real task supplies different wording, use its wording; do not import these invented rules into it.

Work the first case and locate the tempting mistake

Start with B A C D. Seal compares B with D; B comes earlier, so the first and last crates swap. The intermediate row is D A C B. Lift now finds B in the fourth position and swaps it one place left. The final row is D A B C.

The tempting mistake is to remember that B was originally first and skip Lift. That produces D A C B, which is the intermediate state rather than the final answer. A reader can know every individual rule and still fail by evaluating a condition against the wrong state.

Executed practice result: the implementation checks both the intermediate and final rows against these literal expectations. Reversing the operations for this starting row also produces D A C B: Lift does nothing first, then Seal swaps the ends. This gives a concrete counterexample to the assumption that the operations commute.

Test the branches before increasing speed

Explain why the third case does not wrap B to the end, and why the fourth does not move B directly into first place. These are interpretation checks. If you rush into a shortcut such as “always bring B forward,” you may erase the exact condition the problem asks you to implement.

We enumerated all 24 valid starting permutations. Reversing operation order changes the final answer in 11 of them. That count describes this invented rule system, not the difficulty distribution, pass mark, or scoring of a Bending Spoons assessment.

The 38 checks comprise eight literal intermediate/final expectations, 24 groups checking that output labels and input data are preserved, two order-related checks, and four invalid-input checks. These tests support the practice implementation. They do not establish that performance on our exercise predicts an employer’s decision.

Use a small implementation as an explanation aid

def apply_rules(state):
    if len(state) != 4 or sorted(state) != list('ABCD'):
        raise ValueError('Need A, B, C, D exactly once')
    row = list(state)
    if row[0] < row[-1]:
        row[0], row[-1] = row[-1], row[0]
    b_index = row.index('B')
    if b_index > 0:
        row[b_index - 1], row[b_index] = row[b_index], row[b_index - 1]
    return ''.join(row)

assert apply_rules('BACD') == 'DABC'
assert apply_rules('DBCA') == 'BDCA'
assert apply_rules('ACDB') == 'BCDA'
assert apply_rules('CABD') == 'DBAC'

This is practice code, not a suggestion to run assistance during a live task. Its second condition uses B’s position after the first transformation. The validation rule is also our own declared input contract; it does not claim that an employer uses these labels or rejects inputs in this way.

After attempting the exercise without code, compare your written trace with the implementation. Record whether the error was a missed condition, stale intermediate state, unintended repetition, or careless transcription. “I got it wrong” is less useful than identifying which interpretation failed and choosing another case that would expose the same error.

Connect optional practice to the employer’s stated purposes

The official PDF’s distinction between unfamiliar problem solving, job expertise, and behavioral qualities supports three different preparation outputs. Our inference: do not spend all your preparation time memorizing a single puzzle format when the published process describes more than one purpose. The following map is an optional practice design, not an assessment blueprint.

For the engineering variation, separate parsing, state transformation, and test cases. State whether the input is mutated and how invalid input is handled. For the product variation, distinguish an unclear instruction from a correct instruction that users overlook; those explanations suggest different changes and different evidence to collect.

Neither variation requires pretending that your existing expertise is irrelevant. The useful connection is showing how you learn a new contract and then apply the judgment your role requires. The candidate reports help illustrate why one applicant’s route should not determine another applicant’s preparation allocation.

Preserve useful evidence from your own experience

Choose an example in which an unfamiliar problem forced you to revise an initial interpretation. Explain the original goal, what you did not know, the small check that changed your view, your contribution, and the outcome. If the outcome is uncertain, say what remains unmeasured rather than inventing a percentage improvement.

A concise account might explain how you discovered that a requirement applied after a state change, corrected the implementation, and added a regression case. That is a structure for discussing a real experience, not a ready-made personal achievement to claim. Use only events and contributions you can defend under follow-up questions.

For time planning, reserve a focused period based on the actual invitation. Practice may help you recognize your own reading errors, but this guide makes no claim about score gains, guaranteed progression, or how the employer weights any particular response. The known boundary is more useful than a confident invented cutoff.

Five verified exercises for further practice

These are general PracHub questions, not questions attributed to Bending Spoons. Select the skill you want to examine rather than treating the list as a likely exam paper.

Continue with the three-card game exercise, explain one changed rule, and build a case that distinguishes the old and new behavior. For your Bending Spoons invitation, use the current role information and instructions to decide what to do next.

Sources and Further Reading

• Bending Spoons: The Application Process — official general framework, with job-dependent variation.
• Bending Spoons: Graduate software engineer — current official role example; not confirmation of every graduate invitation.
• Bending Spoons: Careers FAQ — official interview-preparation and accommodations guidance.
• Reddit: online tests preparation, April 7, 2026 — self-reported product-management application context.
• Reddit: system-design interview, July 23, 2026 — self-reported Graduate AI Software Engineer invitation context.