Last updated: August 14, 2026
Most Python developer interviews run on autopilot. The interviewer asks the candidate to reverse a linked list, checks whether they know what a list comprehension is, and calls it done. The problem is those questions don’t predict whether someone will ship maintainable Django views, write testable FastAPI services, or communicate effectively across a time zone gap.
The questions below are organized by interview stage and weighted toward what actually predicts performance on a modern Python backend team. For nearshore hiring specifically, there is a dedicated section on evaluating async communication and real-time English, since those are often what determine whether a remote Python hire integrates well or stays siloed.
Before the Interview: What to Assess
Before you schedule a first screen, decide what you are actually trying to measure. Python developers exist across a wide range of roles. A data engineer using Python for pipeline orchestration is not the same hire as a backend web developer building Django REST APIs. Three dimensions matter most regardless of specialization:
Python knowledge depth. There is a meaningful gap between developers who use Python as a scripting layer and developers who understand how the language actually works. Generators, context managers, the GIL, and memory management are not advanced topics in 2026. They are baseline expectations for any mid-senior backend hire. Set your minimum bar here before the first call.
Async and OOP understanding. Modern Python backend development leans heavily on async patterns, especially with FastAPI and the broader shift toward event-driven architectures. A developer who has only written synchronous Django views and never touched asyncio will need significant ramp time on any async codebase. OOP fluency matters too, particularly class design, inheritance trade-offs, and when to favor composition.
Communication quality for nearshore remote collaboration. This is the dimension most interview processes skip entirely. Can the candidate explain a blocker clearly in writing? Do they ask clarifying questions before starting ambiguous work? Will they surface problems early or go silent for two days? These behaviors are predictable from structured interview questions, and they matter as much as technical depth for any embedded remote role.
Python Fundamentals Questions
These questions belong in the first 30-minute technical screen. The goal is to establish that the candidate’s Python fundamentals are solid enough to work in a production codebase without constant correction. A strong candidate does not hesitate on these. They answer quickly and often add context you did not ask for.
__str__ and __repr__?__str__ is the human-readable representation and __repr__ is the developer/debug representation intended to be unambiguous. Strong candidates note that repr() output ideally allows reconstructing the object.with statement.__enter__ and __exit__, the common file-handling example, and ideally a mention of contextlib.contextmanager for creating custom context managers. Candidates who only know it for opening files have limited exposure to production patterns.
Framework-Specific Questions (Django / FastAPI / Flask)
Framework questions should match the stack the candidate will actually use. Asking Django ORM questions to a FastAPI developer wastes interview time and signals that your process is not calibrated. Run through the sub-section that applies and skip the others.
Django Questions
Django developers need to understand the ORM, migrations, and the request lifecycle at depth. Surface-level knowledge of models and views is not enough for mid-senior roles.
select_related() and prefetch_related() for solving N+1 problems, only() and defer() for field selection, and using Django Debug Toolbar or logging the SQL output directly to identify what queries are running. Candidates who jump to “add an index” without first identifying the query are skipping steps.makemigrations and then migrate? What can go wrong?validate() method are building maintenance problems.force_login() or APIClient with force_authenticate() in DRF. Candidates who say “I mock the auth middleware” are working around the framework instead of with it.FastAPI Questions
FastAPI developers need solid async fundamentals and an understanding of how Pydantic integrates with the request/response cycle. These questions test whether their FastAPI knowledge is production-grade or tutorial-level.
Depends() as FastAPI’s mechanism for injecting reusable logic into path operations, with examples like database session management, authentication checks, or configuration injection. Candidates who only know it as “a way to get a DB session” have limited experience with the system’s real power.async def versus a regular def? What is the difference in how FastAPI handles each?async def endpoints run in the event loop and should only use awaitable calls, while regular def endpoints are run in a thread pool executor to avoid blocking. Mixing blocking I/O into an async def endpoint is a common performance bug that this question surfaces.@validator in V1, @field_validator in V2) for custom validation logic.BackgroundTasks for lightweight fire-and-forget work, and Celery or ARQ for heavier background job processing. Candidates who would do heavy processing synchronously before returning a response have not thought through the user-facing implications.Flask Questions
Flask is a microframework. The questions here probe whether the candidate understands Flask’s intentional minimalism and has made informed decisions about how to extend it.
create_app()), blueprints for modular routing, and separation of configuration from application logic. A candidate who has only used Flask for small scripts may not know these patterns exist.flask.request and flask.g available without passing them explicitly. Candidates who have hit “working outside of application context” errors understand this viscerally and should be able to explain it clearly.Skip Building Your Own Process
Kore BPO pre-screens nearshore Python developers through 5 technical stages before you interview. Profiles in 2 to 5 business days.
Async and Concurrency Questions
Async Python is one of the most common sources of production bugs from developers who learned it through documentation rather than production incidents. These questions test whether the candidate understands the execution model, not just the syntax.
await a coroutine?await suspends the current coroutine and yields control back to the loop, and that the loop resumes the coroutine when the awaited task completes. Candidates who say “it just runs things async” without explaining the cooperative scheduling are showing a surface-level understanding that will produce bugs.asyncio.gather() and asyncio.create_task()? When would you use each?create_task() schedules a task immediately while gather() awaits a group of awaitables and collects results. Strong candidates mention that gather() can be configured to handle partial failures with return_exceptions=True.async def endpoint? How do you fix it?asyncio.to_thread() or loop.run_in_executor(). Candidates who have never hit this in production may not know the fix even if they know the problem.AsyncMock from unittest.mock for mocking async dependencies, and the importance of using an actual async database driver (like asyncpg or databases) in integration tests rather than mocking at the wrong level.System Design and Architecture Questions
System design questions for Python developers should reflect what the person will actually own. A developer maintaining one Django service in a larger microservices platform needs a different question than someone who will architect a new data pipeline. Calibrate the complexity to the role.
Remote Collaboration and Soft Skills
These questions evaluate the communication and self-management behaviors that determine whether a nearshore Python developer integrates well with a US team or operates as an isolated contractor. They are not generic culture-fit questions. Each one tests a specific behavior that shows up, or fails to show up, in the first 90 days of an embedded remote role.
Async writing test: Before the final round, send the candidate a technical question by email or Slack and ask them to respond within 24 hours. Ask them to explain a Python design decision they made on a real project, the trade-offs they considered, and what they would do differently. The written response tells you more about their day-to-day communication quality than two additional hours of video interviews.
Red Flags to Watch For
Experienced interviewers develop a list of signals that reliably predict problems in the first sprint. These are the most consistent red flags when evaluating Python developers for nearshore embedded roles.
Cannot explain decorators beyond the syntax. Decorators are a core Python pattern. A mid-senior developer who says “I use them but I am not sure exactly how they work” has significant gaps in their language understanding that will surface in code reviews.
Only talks about CRUD operations. If every project the candidate describes boils down to “I built endpoints that read and write to a database,” they have not worked on anything with meaningful business logic, performance requirements, or architectural decisions. The first time they encounter a complex domain model or a performance constraint, they will be starting from scratch.
No testing experience or vague answers about testing. “I test manually” or “we had a QA team for that” from a backend developer is a disqualifying answer for any mid-senior role. If the candidate cannot describe how they write a unit test for a service function with a mocked database call, they are not writing production-grade code.
Vague on async, confident in the interview. Candidates who have read about asyncio but never debugged a blocking call in production tend to speak confidently about async at a conceptual level but go vague when asked “what happens to other requests while that blocking call runs?” Ask the follow-up. The answer reveals whether their knowledge is theoretical or operational.
Cannot describe a technical decision they pushed back on. Developers who cannot recall a single technical disagreement in their career are either working in isolation, not engaged with the codebase, or telling you what they think you want to hear. All three are problems for an embedded nearshore role.
Silent on blockers. Any candidate who describes waiting two or more days before surfacing a blocker to their team is showing exactly the communication pattern that causes nearshore engagements to fail. It is not a minor trait difference. It is a structural mismatch with distributed team work.
Frequently Asked Questions
How many interview rounds should a Python developer process have?
Three to four structured stages is the right range: a 30-minute phone screen for Python fundamentals, a 60-90 minute technical session covering framework depth and a live coding or take-home problem, a 30-minute system design conversation, and a 20-minute communication and nearshore fit evaluation. More than four rounds loses strong candidates to faster-moving offers. Fewer than three risks missing fundamental gaps that surface in the first sprint.
Should I prioritize Django or FastAPI experience when hiring a Python backend developer?
Prioritize whichever framework matches your actual stack. A strong Django developer does not automatically transfer cleanly to FastAPI, particularly on async patterns and Pydantic-based validation. If you are building a new service and have not committed to a framework yet, FastAPI is the stronger default choice in 2026 for performance-sensitive APIs. For content-heavy applications with admin interfaces, Django’s ecosystem is still unmatched. Ask candidates about their framework reasoning — not just their experience — to see whether they can articulate trade-offs.
What Python version should I ask about in the interview?
Ask about the version your production codebase runs. If you are on Python 3.11 or 3.12, the interview should touch on the performance improvements in those releases and whether the candidate has worked with the updated error messages and traceback formatting. Avoid version trivia questions. What matters is whether the candidate understands the language fundamentals that translate across versions, not whether they can recite the changelog.
How do I evaluate English communication in a nearshore Python developer interview?
Evaluate it across the entire interview rather than treating it as a separate category. Watch whether the candidate volunteers context without being prompted, asks clarifying questions before answering ambiguous questions, and structures their explanations so you can follow them without interrupting. Also send the 24-hour async written test before the final round. Written communication quality is a separate signal from spoken English fluency, and it is often the more important one for developers working in US-based sprint environments.
How does Kore BPO screen nearshore Python developers before presenting them?
Kore BPO runs a five-stage process: a Python fundamentals assessment covering data structures, the GIL, generators, and decorators; a framework-specific live coding test in the candidate’s own environment; a system design interview scoped to the client’s architecture; an async written communication evaluation; and direct reference verification with prior US employers or clients. Candidates who reach your interview have already passed all five stages. More detail on the process is at korebpo.com/nearshore-python-developers.
Disclosure: Kore BPO is a nearshore staffing agency. This guide reflects our direct experience screening Python developers from Costa Rica for US engineering teams.
Related Articles
Get Pre-Screened Python Developers
Kore BPO runs 5 technical screening stages before you see a resume. Costa Rica candidates in 2 to 5 business days.
View Available Python Developers