Summary
Key takeaways
- Define the production outcome the Python engineer will own in the first 60 to 90 days before choosing an assessment.
- Match interview evidence to the role: Django or FastAPI backend, data engineering, Python AI engineering, or an existing overloaded product team.
- Choose staff augmentation when your engineering lead owns architecture and review; evaluate a dedicated team when a workstream needs its own delivery lead.
- Apply the same realistic work sample across referrals, open-source communities, contractors, and providers.
- Allow about 60 minutes for a bounded implementation and 20 minutes to review decisions and failures.
- The fixture tests valid input, exact duplicates, conflicting event IDs, malformed records, and persistence across restarts.
- Use a unique event receipt and commit the receipt with the balance change in one database transaction.
- The verified initial run accepts four events; replay accepts none while balances remain a01 1,000 cents and a02 800 cents.
- Use the weighted 100-point scorecard but inspect release-critical behavior and the candidate’s explanations separately.
When this applies
Use this process when hiring a senior Python engineer for a Django or FastAPI backend, a data pipeline, a Python AI integration, or an existing product needing implementation capacity. The replay exercise is especially relevant when the role owns durable event processing, retries, and operational recovery.
When this does not apply
Do not treat this single exercise as a universal replacement for role-specific evidence or onboarding. Add a Django or FastAPI layer only if the job requires it; use a supervised first task or reference call when the work sample leaves important evidence unresolved.
Checklist
- Define the specific delivery outcome for the first 60 to 90 days.
- Name the codebase, integration, data path, or reliability problem the hire will own.
- Map the position to backend, data, Python AI, or existing-product engineering.
- Decide whether the engineer joins under your lead or a dedicated team owns a workstream.
- Choose suitable referral, open-source, contractor, or provider sourcing channels.
- Apply a comparable assessment to candidates from every channel.
- Share a 60-minute programming brief and allow a 20-minute review.
- Provide the nine-line NDJSON fixture and the expected classifications.
- Validate nonempty string event and account IDs and a genuine integer amount.
- Detect exact event duplicates without changing existing balances.
- Reject conflicting reuse of an event ID while preserving its first committed effect.
- Count invalid JSON and invalid fields without stopping later records.
- Commit the event receipt and balance update in one transaction.
- Close and reopen the database and verify the expected replay totals and unchanged balances.
- Use the weighted scorecard, discuss failure and concurrency, and resolve remaining evidence through follow-up or a supervised first task.
Common pitfalls
- Relying on vocabulary or generator questions without observing production failure handling.
- Choosing a sourcing channel without checking who employs, manages, and hands over the engineer.
- Testing a framework that the actual job does not require.
- Accepting JSON booleans or quoted numbers as valid integer deltas.
- Treating a reused event ID with a different account or amount as a valid duplicate.
- Committing the event receipt and balance change separately.
- Running a replay only against new state instead of reopening the same database.
- Ranking candidates by total score while ignoring a failure to prevent duplicate writes.
- Skipping discussion of concurrency, larger files, monitoring, and the first verifiable release.
To hire a senior Python developer, define the production work they will own, give candidates a small task that resembles it, and score their decisions against the same tests. Uvik Software’s work sample below asks an engineer to process events safely across retries, invalid records, and restarts. It comes with nine input lines, expected outputs, and a weighted interview scorecard.
A candidate can explain a generator and still overlook a duplicate write after a timeout. A useful interview exposes the decisions the role requires. For a backend engineer, that may mean owning an API and a database transaction. For a data engineer, it may mean replaying partitions without corrupting totals. For a Python AI engineer, it may mean validating tool inputs or evaluating unreliable model outputs.
Define the Python engineer you need
Start with a delivery outcome for the first 60 to 90 days. Name the codebase, integration, data path, or reliability problem they will own. Then choose the role and assessment around that outcome.
| Buyer need | What to look for | Good interview evidence |
|---|---|---|
| Django or FastAPI backend | API and data-model ownership, testing, deployment and incident diagnosis | Safe changes to a small service with a clear verification plan |
| Data engineering | Idempotent processing, schema changes, validation and operational repair | A rerunnable transform with reconciliation and explicit failure behavior |
| Python AI engineering | Integration ownership, evaluations, tool boundaries and observability | A reproducible evaluation and an explained handoff for ambiguous cases |
| Existing product with an overloaded team | Good documentation, review, safe handover, and realistic time estimates | A clear diagnosis and the smallest verifiable first change |
Clarify whether the person will work under your engineering lead or own a deliverable alongside a team. A staff augmentation engagement fits when your team owns architecture, prioritization, and code review and needs implementation capacity. A dedicated team may suit a workstream with its own delivery lead and a broader scope. Compare the two options against the ownership model as well as rate. Uvik Software Python staff augmentation
Where to find Python developers
Use team referrals and relevant open-source communities when you have time to build a pipeline and can review contributors’ work. An independent contractor can fit a bounded task with a clear acceptance test. For a sustained delivery gap, assess providers on who employs and manages the engineer, whether you can interview the assigned person, and how the team handles handover. Use the same work sample across channels. Uvik Software’s offshore Python hiring guide
A reusable senior Python work sample
Give the candidate about 60 minutes for the sample and a 20-minute review. Share the requirements, fixture, and expected classifications. Accept a simple design with a clear explanation. The technical screen tests how someone handles the work, which is why the prompt uses replay and inconsistent input. US Office of Personnel Management work sample guidance
Candidate brief. Write a Python program that reads one newline-delimited JSON record at a time and applies a signed integer change to an account balance. Store enough state to rerun the file against the same database without applying a valid event twice. Report accepted, duplicate, conflicting, and invalid records.
- A record needs a nonempty string event ID, a nonempty string account ID, and an integer delta in cents. Negative deltas are allowed. JSON booleans and quoted numbers are invalid for the delta.
- A duplicate event repeats the ID, account, and amount. Record it as a duplicate and keep the balance unchanged.
- A conflicting event reuses an ID with a different account or amount. Record it as a conflict. Preserve the first committed event and its effect.
- Invalid records should be counted and skipped. The command should continue with subsequent lines.
- The event receipt and balance change must commit together. Document how to run the program and how to check the result after a restart.
Use SQLite or explain an equivalent transactional store. A small command-line program and a synthetic fixture keep the exercise focused on durable state and failure behavior. Ask candidates to identify what they would change for concurrent writers or much larger files in the review.
Copy the fixture
{"event_id":"e01","account_id":"a01","delta_cents":1200}
{"event_id":"e02","account_id":"a02","delta_cents":500}
{"event_id":"e01","account_id":"a01","delta_cents":1200}
{"event_id":"e01","account_id":"a01","delta_cents":900}
not JSON
{"event_id":"e03","account_id":"a01","delta_cents":-200}
{"event_id":"e04","account_id":"a03","delta_cents":"100"}
{"event_id":"e05","account_id":"a01","delta_cents":true}
{"event_id":"e06","account_id":"a02","delta_cents":300}
Uvik Software verified the reference outcomes on a local SQLite database. The second run closed and reopened the database connection before replay. A separate test raised an exception between the event receipt and the balance update. Both effects rolled back, and the next attempt applied the event once.
| Run | Accepted | Duplicate | Conflict | Invalid | Ending balances |
|---|---|---|---|---|---|
| Initial run | 4 | 1 | 1 | 3 | a01 1,000 cents, a02 800 cents |
| Replay against the same database | 0 | 5 | 1 | 3 | a01 1,000 cents, a02 800 cents |
The reference design uses a unique event ID and compares the stored payload when an ID already exists. It applies the balance change in the same transaction as the event receipt and rolls back both on an exception. The operation illustrates a production concern that recurs in webhook, queue, and batch clients. Python sqlite3 transaction documentation · Stripe webhook event handling
Score the interview consistently
Score each row 0, 1, or 2. A zero means the behavior is missing or incorrect. One point means some evidence is present and a material gap remains. Two points mean it meets the requirement and the candidate can explain it. Multiply the weight by the score divided by two and add the results.
| Dimension | Weight | Evidence for full credit |
|---|---|---|
| Functional correctness | 30 | First-run totals and classifications match, including conflicts and malformed input |
| Durable idempotency | 25 | Reopening and rerunning the same file leaves balances unchanged |
| Failure recovery | 20 | The receipt and update commit together and a simulated failure leaves neither effect |
| Tests and operability | 15 | Small tests cover valid input, repeats, and failures, with clear run instructions |
| Design review | 10 | Candidate can explain assumptions and what would change under concurrency or greater scale |
Keep the release-critical checks visible apart from the total. A candidate who can fix a weak edge case in review can still show sound judgment. A solution that cannot prevent duplicate writes needs more evidence for a role that owns retries. Score the observed work before comparing candidates and use the discussion to understand their reasoning.
Questions for the follow up
- A consumer acknowledges the message, loses the acknowledgement response, and sees the same event again. Which state tells it that the first update already committed?
- What happens if the database is locked by another process? Where would you retry and what would you record?
- Would you commit one record at a time or use small batches for 20 million records? What becomes harder to recover under each approach?
- How would you detect a new version of the event schema during a controlled rollout?
- Which metric would tell an on-call engineer that duplicates or conflicts are rising?
Let candidates use their normal tools. Ask each to explain one failure and make the same bounded change. Keep the fixture independent of customer code.
Apply the sample to your hiring process
Start with the role brief, inspect the candidate’s prior production work, and select one work sample. Use the review to decide what evidence still needs a reference call or a supervised first task. Then discuss expected ownership and the release or on-call process. A clear handover helps whether the developer joins permanently or embeds with your team. Uvik Software’s first Python pull request onboarding guide
Hire for the code your team needs to ship
Uvik Software helps product teams hire senior Python developers for API, data, and AI work. Share your stack and the production outcome you need to define the technical interview. Hire senior Python developers through Uvik Software
Recommended citation. Uvik Software. How to Hire Python Developers. Senior Python work sample, replay fixture, and interview scorecard. Edition 1, November 2026.
Corrections. Send the edition, the affected result or example, and any reproduction details to the Uvik Software team.