Interview guides · Blue Prism Group

Blue Prism Group Software Engineer Interview Guide

Blue Prism Group Software Engineer interview guide: reported rounds, coding and debugging questions, behavioral prep and a 7-day plan.

The 60-second brief

Blue Prism Group builds robotic process automation (RPA) software, meaning software that carries out business processes people would otherwise perform by hand. Products named in candidate reports include Blue Prism Cloud and Connected-RPA. Candidates describe the Software Engineer role as covering the whole development lifecycle: gathering requirements, turning product managers' user needs into technical specifications, writing and testing code, reviewing teammates' changes and shipping to deployment. The work is described as cross-functional, alongside product management, quality assurance and operations colleagues. The requirements candidates quote list C#, Java or Python, Agile or Scrum experience and familiarity with cloud platforms. Knowledge of RPA tools, machine learning or AI, and user experience design appear as nice-to-have.

This guide is for engineers preparing for the Blue Prism Group Software Engineer loop. It covers the four reported rounds, the reported technical questions (languages, object-oriented versus functional programming, debugging, slow applications, automating a business process, linked-list reversal and coding style), the behavioral prompts, and a seven-day schedule that ties them together.

Candidates report four rounds over roughly three to five weeks: Initial Screening, Technical Interviews, Behavioral Interviews and Discussions with Leadership. These are candidate descriptions of the stages, not a published process.

Focus areas

Technical Interview Preparation
Problem Solving (General)
Understanding of Job Description (JD)

Overview

The reported questions fall into four groups: technical and domain questions (your languages, object-oriented versus functional programming, debugging), problem-solving scenarios (a hard technical problem you solved, a slow application, designing an automation for a business process), coding (reversing a linked list, narrating your reasoning, keeping code efficient and maintainable) and behavioral or leadership questions. Candidates also report that live coding is a common expectation, so plan to write working code while explaining it, not just discuss it.

The product context shapes the design scenario. RPA software runs a business process step by step on behalf of a person, so a good answer to the automation question names the pieces any such system needs: how the process is broken into steps, where the input data comes from, what happens when a step fails or an input is malformed, how a run is retried without repeating side effects, what gets logged for audit, and when a human takes over. You do not need prior RPA experience, since the requirements candidates quote list RPA tools only as nice-to-have, but reading the public descriptions of Blue Prism Cloud and Connected-RPA before the loop lets you speak about the problem concretely.

The stack named in the requirements is C#, Java or Python, with Agile or Scrum and cloud platforms. Pick the language you are fastest in and use it for all coding practice, then be ready to discuss one project in each language you list on your CV. The role description mentions code reviews and testing, so expect to be able to talk about how you write tests, what you look for when reviewing someone else's change, and how you keep a function readable after it is fast.

Three of the four rounds are about how you work with people: behavioral interviews, a final discussion with leadership, and the reported behavioral prompts on difficult teammates, leading a project and juggling deadlines. Build a small bank of real stories, each with your own decision and a result, and reuse them across the rounds rather than inventing new ones each time.

The Blue Prism Group interview process

Candidates report four rounds over about three to five weeks, listed in this order: Initial Screening, Technical Interviews, Behavioral Interviews, Discussions with Leadership.

Initial Screening

Candidates describe an initial screening that checks basic qualifications and fit. No question list is attached to this stage in the reports, so treat it as a conversation about your background and the role. The requirements candidates quote name C#, Java or Python, Agile or Scrum, and cloud platforms, so be ready to say which of these you have used and where. Approach it by having a short, concrete account of your recent work and a clear reason for this role.

What to demonstrate

Whether your background matches the stated requirements (languages, delivery methodology, cloud exposure)
Fit for the role, as the stage is described
How clearly you summarise your own experience

How to prepare

Write a short account of your last two projects: what you built, which language you used, and your own contribution.
Match your experience to the listed requirements (C#, Java or Python; Agile or Scrum; cloud platforms) and note one example for each you can claim.
Read the public product pages for Blue Prism Cloud and Connected-RPA so you can say what the product does in your own words.
Ask the recruiter to confirm the remaining stages and who you will meet.

Technical Interviews

Candidates describe in-depth technical conversations with technical leads and team members. The reported technical questions cover your languages and projects, object-oriented versus functional programming, how you debug, how you would speed up a slow application, how you would design an automation for a business process, and coding such as reversing a linked list. Candidates also report that live coding is common. Approach it by practising spoken answers and working code in the same language, and by outlining each answer before filling in detail.

What to demonstrate

Working code written live, since live coding is reported as common
Technical depth in the languages and concepts the role lists
A structured way of breaking a problem into steps
Ability to explain technical decisions in plain language

How to prepare

Solve the linked-list reversal iteratively with prev, current and next pointers, then recursively, and state the time and space cost of each.
Rehearse a debugging sequence: reproduce, narrow the scope, form a hypothesis, test it, confirm with a regression test.
Prepare a measure-first answer for the slow application: profile, find the hot path, then change one thing and re-measure.
Outline a design for automating a business process: steps, data input, failure handling, retries, logging and human hand-off.

Behavioral Interviews

Candidates describe behavioral interviews that focus on collaboration and cultural fit. The reported behavioral prompts are about working with a difficult team member, leading a team or project, and prioritising under multiple deadlines. Approach this stage with a set of true stories told in a Situation, Task, Action, Result structure, where the Action portion is about what you personally decided.

What to demonstrate

How you describe collaboration with teammates and cross-functional colleagues
Your handling of conflict and competing priorities, as the reported prompts frame them
How clearly you separate your own contribution from the team's

How to prepare

Write three stories on index cards: one conflict with a colleague, one project you led, one occasion with competing deadlines.
For each story, write the decision you made, the alternative you rejected, and a result you can state with a number or an observable change.
Include at least one story that involves a product manager, a tester or an operations colleague, since the role is described as cross-functional.
Say each story aloud and trim it until the situation takes two or three sentences.

Discussions with Leadership

Candidates describe final discussions with leadership about overall compatibility and alignment. The reports do not list questions for this stage, so prepare broadly: the leadership and prioritisation stories from the behavioral round, a clear account of why you want this role, and your own questions about the team and product. Approach it as a conversation where you explain your judgment, not a coding exercise.

What to demonstrate

Overall compatibility and alignment, as the stage is described
How you describe your scope of ownership and the trade-offs you have made
Whether your questions about the role show you have studied the product

How to prepare

Rehearse the project-you-led story with a clear scope, a decision under uncertainty and a result.
Prepare your prioritisation answer around one real instance of two deadlines colliding, including what you deferred and who you told.
Write three questions about how the team ships software, reviews code and works with product, quality assurance and operations.
Be ready to say, in a few sentences, why Blue Prism Group and why this role.

Where candidates lose points

Answering the languages question with a list of names and no projects

For each language you list (C#, Java or Python are the ones named for the role), prepare one project with your role, one design choice and one thing you would change. Drop any language you cannot discuss at that depth.

Defining object-oriented versus functional programming without showing either

Take one small problem, such as transforming a list of orders, and write it both ways: objects with mutable state against pure functions and immutable data. Say where each makes testing easier and that most real code mixes the two.

Losing the next pointer or skipping edge cases in the linked-list reversal

Save current.next before you rewrite it, return the old tail as the new head, and check an empty list, a single node and two nodes. Narrate each step as you write, since live coding is reported as common.

Proposing fixes for a slow application or a hard bug before measuring anything

Lead with reproduction and measurement: profile or trace to find the hot path, change one thing at a time, and re-measure. Name a regression test or a metric that shows the fix held.

Behavioral stories told as 'we' with no personal decision, or that blame a colleague

Write each story with the decision you personally made and a result you can observe. Describe the difficult colleague's behaviours neutrally and include what you changed on your side.

Questions & practice

Write a function to reverse a linked list.

Medium · Coding / Algorithms

Approach

Iterative solution: keep prev = null and curr = head. In a loop, save next = curr.next, point curr.next at prev, then move prev = curr and curr = next. When curr is null, return prev as the new head. O(n) time, O(1) extra space.
Say why next must be saved first: once curr.next is overwritten, the rest of the list is unreachable.
Recursive alternative: reverse the rest of the list, set head.next.next = head and head.next = null, then return the new head. It is also O(n) time but uses O(n) stack, so a long list can overflow the stack (Python's default recursion limit is about 1000).
Trace the edge cases out loud: an empty list (return null), a single node (returned unchanged), and two nodes. Confirm the old head's next is null afterwards, so the result has no cycle.

Follow-up

Reverse only the nodes between positions m and n in one pass.
Reverse the list in groups of k, leaving a final group shorter than k as it is.
How would you check whether a linked list is a palindrome using O(1) extra space?

Explain your thought process while solving this algorithmic challenge.

Medium · Coding / Algorithms

Approach

Restate the problem in my own words and ask about constraints: input size, value ranges, duplicates, sorted or not, and the expected output for empty input. The size of n sets the target, since n around 10^5 rules out O(n^2) and points to O(n log n) or O(n).
Work one small example and one edge case by hand, then state the brute-force solution with its complexity before improving it, so there is a correct baseline.
Name the bottleneck and the pattern that removes it: a hash map for repeated lookups, two pointers or binary search on sorted data, a sliding window for contiguous ranges, a heap for top-k, BFS/DFS for graphs, or dynamic programming when subproblems overlap.
Write the code while narrating the invariant each loop keeps. Then dry-run it on the example and the edge cases, and finish with the final time and space complexity.

Follow-up

Your solution is O(n log n). Is O(n) possible, and what would it cost in memory?
What changes if the input arrives as a stream and does not fit in memory?
Which test case would most likely break your code, and why?

How do you ensure your code is both efficient and maintainable?

Medium · Coding / Algorithms

Approach

Efficiency starts with choices made up front: the right data structure for the access pattern (a hash set for membership, not a list scan) and knowing the complexity of library calls. Beyond that, optimise only what profiling or a benchmark shows matters (BenchmarkDotNet, JMH, timeit).
Maintainability comes from small functions with one responsibility, clear names, explicit types or type hints, and dependencies passed in rather than hard-coded, so the code can be tested and changed in isolation.
Treat automated tests as the safety net that makes refactoring and optimisation safe: unit tests for logic, a few integration tests for boundaries, all run in CI with linters and static analysis.
When the two goals conflict, keep the fast but complex part behind a simple interface, comment why it exists, and keep the benchmark that justified it. Give one example from your own work.
Mention code review as the habit that enforces both, and say what you look for when reviewing someone else's change.

Follow-up

Describe a time you made code less readable to make it faster. Was it worth it?
A pull request is correct and fast but hard to follow. What feedback do you give?
How do you decide when technical debt is worth paying down versus shipping the feature?

Keep soft-deleted accounts from blocking re-registration

Easy · soft delete · unique constraints · engine differences

app_user holds user_id, tenant_id, email CITEXT, password_hash (NULL for SSO principals), email_verified_at, auth_version, status ('invited','active','suspended','deactivated'), created_at, updated_at, deleted_at. Two live accounts for one address inside a tenant must be impossible, but an address freed by a soft delete must be reusable, and the same tenant may delete and re-register it repeatedly. Write the uniqueness DDL for PostgreSQL 16, then the equivalent for MySQL 8 where partial indexes do not exist, and say what each permits once three deleted rows already hold that address.

Approach

Start from what is actually unique: not (tenant_id, email), but (tenant_id, email) among live rows. PostgreSQL says that directly — CREATE UNIQUE INDEX app_user_live_email ON app_user (tenant_id, email) WHERE deleted_at IS NULL. A full constraint over the same two columns burns the address permanently the first time someone deletes an account.
Keep case-insensitivity in the type or the index, never in the application: CITEXT as given, or UNIQUE (tenant_id, lower(email)) as an expression index where the extension is unavailable. A case-sensitive unique column is exactly how two accounts for one human appear.
For MySQL 8 the predicate has to move inside the key: add a discriminator column that is a constant 0 while the row is live and is set to user_id on delete, with UNIQUE (tenant_id, email, deleted_marker). Live rows share the constant and still collide; deleted rows differ from each other and stop colliding.
State the NULL variant and its dependency: leaving the marker NULL for deleted rows also works, because a unique index treats NULLs as distinct — true in MySQL, and true in PostgreSQL only under the default NULLS DISTINCT, which PostgreSQL 15 lets you reverse. Check the polarity against the three existing deleted rows: constant-on-live is what preserves the collision you want, and reversing it silently admits duplicate live accounts.

Follow-up

A deleted account re-registers with the same address the next day. Do the old resource rows follow the new user_id, and how does the API keep the two principals apart?
How do you honour an erasure request while resource_revision.actor_user_id still references this table?

Hold a per-tenant active cap against concurrent creates

Hard · write skew · isolation levels · constraints

A tenant on the standard plan may hold at most 50 resources with status='active'. The create handler runs SELECT count(*) FROM resource WHERE tenant_id = $1 AND status = 'active', compares to 50, then inserts. Two creates arrive 3 ms apart on different instances and the tenant lands at 51. Name the anomaly, say whether PostgreSQL 16 READ COMMITTED or REPEATABLE READ prevents it and why, then give an implementation that holds the cap at READ COMMITTED with the exact statements. Finally, say what changes when the cap is 'at most one running export per tenant' on job_run.

Approach

Name it: write skew. The two transactions read an overlapping set and write disjoint rows, so there is no row-level conflict for the engine to detect and each commit is individually legal.
Rule out the levels precisely. READ COMMITTED takes a fresh snapshot per statement and takes no lock on the counted rows, so both see 49. PostgreSQL's REPEATABLE READ is snapshot isolation: it removes non-repeatable reads and phantoms within the snapshot but still admits write skew, because the anomaly is not a re-read of a changed row, it is a read of a set that a concurrent transaction invalidates. Only SERIALIZABLE closes it, by tracking the read dependency and aborting one transaction with SQLSTATE 40001 — a guarantee that exists only if the application re-runs the whole transaction from the read.
Convert the set predicate into a single-row conflict: keep tenant.active_resource_count and run UPDATE tenant SET active_resource_count = active_resource_count + 1 WHERE tenant_id = $1 AND active_resource_count < 50 in the same transaction as the INSERT. Zero affected rows is the cap, returned as 409. The row lock serialises the decision at any isolation level, and contention is bounded to one tenant's row — which is also the fair-scheduling unit, unlike a global counter that would convoy every tenant behind one row.
State the cost you just took on: a counter is a second source of truth that can drift, so every path that changes status must adjust it inside the same transaction, and a periodic reconciliation has to exist, with resource_revision as the authority for what the count should have been.

Follow-up

A resource moves from archived back to active. Which statements change, and what breaks if the counter update and the status change land in different transactions?
The cap becomes plan-dependent and a plan can change mid-month. Where does the number 50 live, and who reads it?

What programming languages are you proficient in, and can you provide examples of projects utilizing them?

Medium · Technical / Domain Questions

Approach

Lead with one or two languages you can defend in depth rather than a long list. The requirements candidates describe for this role name C#, Java or Python, so if you know one of them, put it first and be honest about your level in the others.
For each language, give one project: what it did, which part you personally wrote, and its scale (users, requests, data volume). Example: 'I wrote the ingestion service in C# with async/await, because the work was mostly waiting on network I/O.'
Name a decision that depended on the language: Python's GIL pushing CPU-bound work to multiprocessing, Java or C# generics and static typing catching errors at compile time, or a GC pause you had to tune around.
Close each example with how you tested and shipped it (unit tests, CI, code review) and a measurable result, so the answer shows engineering practice as well as syntax.

Follow-up

In the language you know best, how does memory management work, and when has it caused you a problem?
What is something your main language makes awkward, and how did you work around it in that project?
If you had to rewrite that project in a different language, which would you pick and why?

Explain the differences between object-oriented programming and functional programming.

Medium · Technical / Domain Questions

Approach

Define both. OOP models a program as objects that bundle state with the methods acting on it, using encapsulation, inheritance and subtype polymorphism. FP builds programs from pure functions, avoids shared mutable state, and uses functions as first-class values (map, filter, fold, composition).
Explain the practical consequences. Pure functions with immutable data are easier to test and safer under concurrency, because there is no shared state to race on. OOP is a natural fit for long-lived entities whose state changes, such as a connection or a UI widget.
Give the extensibility trade-off (the expression problem). With classes it is easy to add a new type but costly to add a new operation across all types. With algebraic data types and pattern matching it is the other way round.
Show that mainstream languages mix the two: C# has LINQ, lambdas, records and pattern matching; Java has streams, lambdas and records; Python has first-class functions, comprehensions and functools. Then give one place where you used a functional style inside an OO codebase.

Follow-up

Is a function that writes a log line pure? How would you structure code so side effects stay at the edges?
When does a deep inheritance hierarchy become a problem, and what would you use instead (composition, interfaces)?
How does immutability affect performance, and how do persistent data structures or copy-on-write reduce the cost?

Describe a challenging technical problem you faced and how you resolved it.

Medium · Problem-Solving / Case Studies

Approach

Choose a problem that was hard for a technical reason (a constraint, an ambiguous failure, a scale limit), not just a busy week, and where you personally made the key decisions.
Set the context briefly: the system, the symptom or goal, and the constraint that made the obvious fix unworkable (latency budget, a legacy API, data you could not lose).
Spend most of the answer on the reasoning: the two or three options you weighed, the evidence you gathered (profiles, logs, a prototype), and why you rejected the alternatives.
End with a measured outcome (latency, error rate, hours saved) and one thing you would do differently. Say 'I' for your own work and give credit to others explicitly.
The answer that sinks you is vague: no numbers, 'we' throughout, and a solution with no alternatives considered.

Follow-up

What was the riskiest part of your fix, and how did you limit the damage if it went wrong?
If you had half the time, what would you have shipped instead?
How did you confirm your change caused the improvement and not something else?

How would you optimize a slow-running application?

Medium · Problem-Solving / Case Studies

Approach

Define 'slow' before changing anything: which operation, at what percentile (p50 vs p95/p99), under what load, and against what target. Reproduce it with the same data volume and load in a test environment.
Profile rather than guess (py-spy or cProfile for Python, dotnet-trace or Visual Studio profiler for .NET, Java Flight Recorder for the JVM). Work out whether time goes to CPU, I/O wait, lock contention or GC/memory pressure.
Fix the biggest measured cost first. Common causes: N+1 queries (batch or join them), a missing index (check EXPLAIN), an O(n^2) loop that a hash map makes O(n), synchronous I/O that could run concurrently, missing connection pooling, or repeated work that a cache with a clear invalidation rule could serve.
Re-measure under the same conditions after each change, one change at a time. Keep a performance test or dashboard alert so the regression cannot quietly return.

Follow-up

The profile shows most time inside database calls. What do you check next?
You add a cache and latency drops but users see stale data. How do you choose the expiry and invalidation strategy?
Memory grows steadily until the process restarts. How do you find the leak?

Given a hypothetical scenario, how would you design a solution for automating a specific business process?

Medium · Problem-Solving / Case Studies

Approach

Pin down the process first with one example, such as invoice intake into an ERP: what triggers it (email, file drop, schedule), the volume, the systems it touches, which steps are rule-based and which need human judgment, and what a failure costs.
Design around a work queue. A trigger creates one item per case. Workers (bots or services) take items with a lease, so a crashed worker's item comes back. Each item carries a status (pending, in progress, done, failed, needs review) and a full audit trail.
Separate the two kinds of failure. Transient system errors get retries with exponential backoff. Business exceptions (missing PO number, amount mismatch) go to a human review queue instead of retrying. Use an idempotency key per item so a retry never posts the same invoice twice.
Integrate through an API wherever the target system has one. UI-level automation breaks when screens or selectors change, so isolate it behind one adapter and add health checks. Keep credentials in a vault, not in the workflow.
To scale, add workers against the queue and respect the target system's rate limits. Measure success by straight-through rate, exception rate, processing time per item and manual hours saved.

Follow-up

A worker submits the record and crashes before marking the item done. What happens on retry, and how do you prevent a duplicate?
The target application changes its UI overnight. How do you detect the breakage, and how do you limit its impact?
How would you decide that a step should stay manual rather than be automated?

How do you approach debugging complex issues in your code?

Medium · Technical / Domain Questions

Approach

First get a reliable reproduction, then shrink it to the smallest input and environment that still fails. Read the full error and stack trace before forming any theory.
Write down a list of hypotheses and test the cheapest one that rules out the most possibilities. Bisect: use git bisect between the last good commit and the first bad one, halve the failing input, or turn components off one at a time.
Use the right tool for the symptom: a debugger with conditional breakpoints for logic errors, structured logs with correlation IDs for multi-service flows, and a profiler or memory dump for performance problems or leaks.
For intermittent bugs, suspect timing and shared state: race conditions, missing awaits, retries that are not idempotent, time zones, or cache staleness. Make them reproducible with stress loops or injected delays.
Finish by explaining the root cause rather than only the trigger. Add a regression test that fails without the fix, and check whether the same pattern exists elsewhere in the code.

Follow-up

The bug only appears in production and you cannot attach a debugger. What do you do?
The bug disappears when you add logging or step through it. What does that suggest, and how do you continue?
How does git bisect work, and what makes it unreliable on a flaky test?

Suggested practice checklist

The plan follows the reported loop: screening and background first, then the technical questions (languages, paradigms, coding, debugging, slow applications, automation design), then behavioral and leadership stories, and a full rehearsal on the last day.

Day 1 — Map the loop and your language inventory

Write the four reported rounds in order and next to each note which reported questions you are least ready for.
List the languages on your CV and match them to the role's requirements (C#, Java or Python; Agile or Scrum; cloud). For each, write one project with your own contribution.
Practise saying your language-and-projects answer aloud.

Deliverable: A one-page loop map with weak spots marked, plus a project note for each language you plan to claim and a spoken version of the answer.

Day 2 — Object-oriented versus functional programming

Write a small order-processing task twice in your best language: once with classes and mutable state, once with pure functions and immutable data.
Write a comparison covering state, testing, concurrency and when you would choose each.
Say the comparison aloud in under a couple of minutes without reading.

Deliverable: Two working implementations of the same task and a short spoken comparison with one example from your own work.

Day 3 — Live coding: linked-list reversal and narration

Reverse a singly linked list iteratively and recursively in your chosen language, and state time and space complexity for each.
Test on an empty list, one node and two nodes, and fix any mistake.
Solve one more algorithm problem while speaking your reasoning aloud from restating the problem to testing it.
Review the finished code for naming, duplication and a clear function signature.

Deliverable: Two tested reversal implementations, one narrated solution to a second problem, and a note on what you would refactor for maintainability.

Day 4 — Debugging and slow applications

Write your debugging sequence as numbered steps: reproduce, narrow, hypothesise, test, fix, add a regression test.
Pick a real slow endpoint or query you have fixed, or build a tiny slow example, and write what you measured, what you changed and how much it improved.
List the usual causes you would check in order (repeated database calls, missing indexes, large payloads, blocking calls, memory pressure).

Deliverable: A one-page debugging checklist and a worked performance example with before and after measurements.

Day 5 — Design an automation and tell the hard-problem story

Choose a business process such as invoice approval and write a design: steps, input sources, failure handling, retry without duplicate side effects, audit logging and a human hand-off.
Say the design aloud, stating the assumptions you make and the questions you would ask first.
Write your hardest technical problem story: the symptom, your hypotheses, what you tried and the fix.

Deliverable: A design outline for one automated process and a written hard-problem story with a result.

Day 6 — Behavioral and leadership stories

Write three Situation, Task, Action, Result stories: a difficult colleague, a project you led, and colliding deadlines.
For each, mark the decision you personally made and the result you can observe.
Say each story aloud and cut it so the setup takes two or three sentences.

Deliverable: Three rehearsed stories on cards, each with a decision, a rejected alternative and a result.

Day 7 — Full rehearsal and your questions

Run a mock loop with a friend or a recording: a language-and-projects answer, a linked-list reversal, a debugging answer and one behavioral story.
Review where you hesitated or went over and tighten those answers.
Write three questions for the team and leadership about how they ship, review and test software.

Deliverable: A recorded or reviewed mock run with a list of fixes, and three prepared questions.

Teamwork, leadership and prioritisation stories

The behavioral and leadership stages are described as covering collaboration and cultural fit, and the reported prompts concern a difficult colleague, leading a project and handling several deadlines. The role is described as cross-functional, so use stories involving product, quality assurance or operations colleagues where you can, and make each story show a decision you made.

Tell me about a time a code review led you to change your approach.
Describe a time you worked with a product manager or tester to change a requirement.

Can you describe a time when you had to work with a difficult team member? How did you handle it?

Medium · Behavioral / Leadership

Approach

Choose a conflict about the work, such as review feedback, missed handoffs or a disputed design, rather than a personality clash. A story that is purely about someone being unpleasant gives you little to show.
Structure it as Situation, Task, Action, Result: two sentences of context, then spend most of the time on what you did, such as asking privately what constraint the other person was under and proposing a concrete working agreement.
Show you tried a direct conversation first and describe what you changed about your own approach; bring in a manager or escalate only after that, and say why.
Close with a result you can observe: a shorter review turnaround, a shipped release, a working relationship that held. Avoid ending with 'and they eventually left' or any version where you simply won.
Do not name or criticise the person. Describe behaviours and their effect on the work in neutral terms.

Follow-up

What if the person had not changed after your conversation? When would you have involved your manager?
What did you learn about your own part in the friction?
How did you keep delivering with the rest of the team while this was unresolved?

Share an example of how you have led a team or project successfully.

Medium · Behavioral / Leadership

Approach

Pick a project where you owned decisions, even without a formal title. Open with scope: what was being delivered, how many people, and what the deadline or risk was.
Name your specific actions: how you split the work, who owned which piece, how you ran check-ins, how you handled a blocker or cut scope. A list of what the team did does not show leadership.
Include one moment where it went wrong or someone disagreed, and show how you recovered. A story with no friction reads as unbelievable.
Report the result and what you would change: a delivered feature, a defect rate that fell, a handover that other people could run. If you used Agile or Scrum practices such as planning or retrospectives, say how they changed the outcome.
Keep first person singular for your actions and say 'the team' only for what the group did.

Follow-up

How did you decide what to cut or delay when time ran short?
How did you handle a team member who was falling behind or disagreed with your plan?
What would you do differently if you led it again?

How do you prioritize tasks when faced with multiple deadlines?

Medium · Behavioral / Leadership

Approach

Give a rule and then an example. The rule: list everything due, estimate effort, rank by cost of delay and dependencies (what blocks someone else), and then renegotiate what cannot fit instead of silently working longer hours.
Tell one real case with two or more deadlines colliding. State what you did first, what you deferred, and who you told and when. Early communication to the person waiting is often the part that makes the answer credible.
Mention how you handle interruptions such as a production defect: triage severity, decide whether it displaces planned work, and tell the affected stakeholders about the trade-off.
Show the result honestly: what shipped on time, what moved and the agreed new date. A story where you somehow did everything shows no prioritisation.
Avoid a generic answer ('I make a to-do list and work hard'); name the actual criteria you used for ranking.

Follow-up

What if two managers each said their task was the most urgent?
What would you do if your estimate turned out to be wrong halfway through?
How do you decide when to push back on a deadline instead of absorbing it?