Interview - AI Engineer

1

Critical

0 / 4 points

How do you approach software development in terms of qualitative standards? What practices do you use to produce high-quality software? (clean architecture, testing, ...)

Testing: Unit tests (pytest), integration tests, end-to-end tests, min. 80% code coverage, TDD approach for critical components

Clean Architecture: Separation of concerns (repository pattern, dependency injection), SOLID principles, hexagonal/onion architecture for larger projects

Code Quality Tools: Linters (ruff, pylint), formatters (black, isort), type checking (mypy), pre-commit hooks, CI/CD pipeline with quality gates

Documentation & Review: Docstrings, README, ADR (Architecture Decision Records), code reviews, pair programming for complex features

2

Critical

0 / 4 points

How do you approach testing? If writing unit tests - what's the recipe for good unit tests? What are common anti-patterns? Any TDD experience?

Good unit test: Fast, Independent, Repeatable, Self-validating, Timely (F.I.R.S.T), tests one thing, clear arrange-act-assert structure, meaningful names

Anti-patterns: Testing implementation details (not behavior), flaky tests, slow tests, test interdependencies, testing private methods directly, over-mocking

TDD workflow: Red-Green-Refactor cycle, write test before code, test defines API/interface, refactor for clean code, use for critical/complex logic

Testing pyramid: Many unit tests (fast, cheap), fewer integration tests, minimum E2E tests (slow, expensive), fixtures and mocking (pytest fixtures, unittest.mock)

3

Hard

0 / 4 points

Explain Python Event Loop (asyncio).

Basic concept: Event loop is single-threaded mechanism for concurrent async code execution, uses async/await syntax, non-blocking I/O operations

How it works: Loop waits for events (I/O ready, timer expires), executes callbacks/coroutines, switches between tasks when waiting for I/O (await), not parallelism (GIL)

Use cases: Web servers (FastAPI/aiohttp), DB queries (asyncpg), HTTP requests (aiohttp/httpx), concurrent I/O bound tasks, not for CPU-bound (use multiprocessing)

Practically: asyncio.run() or asyncio.get_event_loop(), async def functions are coroutines, await yields control back to loop, asyncio.gather() for concurrent tasks

4

Easy

0 / 3 points

What is GIL (Global Interpreter Lock)?

Definition: Mutex/lock that allows only one thread to execute Python bytecode at a time, prevents race conditions in CPython memory management

Consequences: Multi-threading in Python does NOT help for CPU-bound tasks (can't run in parallel), I/O bound tasks OK (GIL released during I/O wait)

Solutions: Multiprocessing for CPU-intensive work (each process has own GIL), asyncio for I/O-bound, NumPy/C extensions bypass GIL, Python 3.13+ has experimental free-threaded mode

5

Easy

0 / 3 points

What are virtual environments for? How do you manage them? (virtualenv, uv, venv, poetry...)

Purpose: Isolate dependencies between projects, avoid package version conflicts, reproducible environment (requirements.txt/poetry.lock)

Tools: venv (built-in Python 3.3+), virtualenv (faster), poetry (dependency management + venv), uv (ultra-fast, Rust-based), conda (data science)

Best practices: One venv per project, commit requirements.txt/pyproject.toml (NOT venv folder), activate before work (source venv/bin/activate), use .gitignore for venv

6

Hard

0 / 4 points

What is dependency injection? How do you implement it in FastAPI stack?

Concept: Design pattern where dependencies are provided from outside (not created internally), improves testability, loose coupling, SOLID principles

FastAPI DI system: Depends() function, declare dependencies in function signature, FastAPI automatically resolves and injects them

Example: DB session injection (def get_db()), authentication (get_current_user), pagination, caching, dependencies can have sub-dependencies (chain)

Benefits: Easy mocking in tests (override dependencies), reusable logic, automatic cleanup (yield pattern), type hints + auto documentation

7

Easy

0 / 3 points

How would you implement an interface in Python?

ABC (Abstract Base Classes): from abc import ABC, abstractmethod, define abstract methods, subclasses must implement, runtime error if not

Protocol (PEP 544): Structural subtyping (duck typing with type checking), from typing import Protocol, no runtime checks, only static type checkers (mypy)

Use case: Repository pattern (DB abstraction), plugins/drivers, dependency inversion principle, easy mocking in tests, prefer Protocol for modern Python (3.8+)

8

Medium

0 / 4 points

What's the difference between List, Set, Tuple, and Dictionary?

List: Ordered, mutable, allows duplicates, [1,2,3], O(1) append/access by index, O(n) search, use case: sequences, stacks

Tuple: Ordered, immutable, allows duplicates, (1,2,3), faster than list, hashable (can be dict key), use case: constants, function returns

Set: Unordered, mutable, NO duplicates, {1,2,3}, O(1) add/remove/lookup, use case: membership testing, remove duplicates, set operations (union, intersection)

Dictionary: Unordered (Python 3.7+ insertion order), mutable, key-value pairs, {'a': 1}, O(1) lookup, keys must be hashable, use case: mappings, caching, config

9

Medium

0 / 3 points

What is Python Generator?

Definition: Function with yield statement, returns iterator, lazy evaluation (generates values on-the-fly), pauses execution at yield, resumes at next()

Advantages: Memory efficient (don't load all into memory), infinite sequences possible, pipeline processing, faster for large datasets than lists

Use cases: Reading large files line-by-line, streaming data, pagination, infinite sequences (fibonacci), ETL pipelines, generator expressions (x**2 for x in range(1000))

10

Easy

0 / 2 points

How do you get the dimensions of a DataFrame (pandas)?

Shape: df.shape returns tuple (rows, columns), e.g. (100, 5) = 100 rows, 5 columns

Alternatives: len(df) = number of rows, len(df.columns) = number of columns, df.info() = detailed info (dtypes, memory), df.describe() = stats

11

Medium

0 / 4 points

What are the benefits of containerization (Docker)? How is it different from running directly on host?

Isolation: Process/filesystem/network isolation, dependency conflicts resolved (each container has own dependencies), security (sandboxing)

Reproducibility: "Works on my machine" problem solved, Dockerfile = infrastructure as code, same environment dev/staging/prod, version control for images

Portability: Run anywhere (Linux/Mac/Windows/Cloud), easy deployment, rollbacks (tagged images), microservices architecture, orchestration (Kubernetes)

Difference vs host: Containers share OS kernel (not full VM), lightweight (MB vs GB), faster startup, but not 100% isolation like VM, host has direct hardware access

12

Hard

0 / 3 points

What cloud providers do you have the most experience with? For what?

AWS: EC2 (compute), S3 (storage), RDS (DB), Lambda (serverless), ECS/EKS (containers), CloudWatch (monitoring), IAM (security), VPC (networking)

GCP: Compute Engine, Cloud Storage, BigQuery (data warehouse), Cloud Functions, GKE (Kubernetes), Pub/Sub (messaging), Vertex AI (ML)

Azure: Virtual Machines, Blob Storage, Azure SQL, Azure Functions, AKS, DevOps (CI/CD), Cognitive Services | Practical use cases: hosting APIs, data pipelines, ML models

13

Easy

0 / 4 points

Consider you have an API server and there's a performance issue. How would you approach the investigation to fix the cause? Any experience with performance profilers?

Monitoring: Check metrics (response time, CPU, memory, DB queries), logs (errors, slow queries), APM tools (New Relic, DataDog), identify slow endpoints

Profiling: Python profilers - cProfile (function calls), line_profiler (line-by-line), memory_profiler, py-spy (production), visualization with flame graphs

Common culprits: N+1 queries (DB), blocking I/O operations, large payloads, missing indexes, memory leaks, synchronous API calls, unoptimized queries

Fixes: Caching (Redis), connection pooling, async operations, pagination, DB query optimization, load balancing, CDN for static assets, code optimization (algorithms)

14

Medium

0 / 4 points

Consider a performance issue during SQL SELECT query, what are the typical causes?

Missing indexes: Full table scan instead of index scan, EXPLAIN ANALYZE for query plan, indexes on WHERE/JOIN/ORDER BY columns

JOINs: Too many JOINs (5+), JOINs on large tables without indexes, cartesian product (missing JOIN condition), sometimes better multiple queries than one big JOIN

SELECT *: Fetching unnecessary columns, large BLOBs/TEXT fields, better to explicitly name needed columns, use pagination (LIMIT/OFFSET)

Other: Subqueries instead of JOINs, functions in WHERE (prevents index usage), outdated statistics, table locks, suboptimal data types, denormalization can help

15

Medium

0 / 3 points

SQL vs NoSQL - what do you typically use and why?

SQL (PostgreSQL, MySQL): Structured data, ACID transactions, complex queries/JOINs, data integrity (foreign keys), reporting, analytics, financials - default choice

NoSQL - Document (MongoDB): Flexible schema, nested objects, rapid prototyping, CMS, catalogs; Key-Value (Redis): caching, sessions, rate limiting; Time-series (InfluxDB): metrics, IoT

Decision: SQL for majority use cases (relational data, transactions), NoSQL for specific needs (scale-out, flexible schema, high throughput), often hybrid approach

16

Critical

0 / 3 points

How would you implement TTL (Time To Live) in PostgreSQL? Without using Redis

Column + scheduled job: Add expires_at TIMESTAMP column, scheduled job (cron/pg_cron) deleting DELETE FROM table WHERE expires_at < NOW()

Partitioning: Time-based partitions (daily/weekly), DROP old partitions (faster than DELETE), automatic partition management extensions

View + trigger: Materialized view filtering expired rows, trigger on DELETE, or application-level filter WHERE expires_at > NOW() in queries, vacuum for cleanup

17

Medium

0 / 4 points

Any AI inference experience? Any experience integrating AI using frameworks like Langchain or similar? For GenAI, what to be careful about? (costs, how to calculate them, ...)

Inference: Model serving (FastAPI, TensorFlow Serving), batch vs real-time, GPU vs CPU, model optimization (quantization, pruning), versioning, A/B testing

Langchain: Framework for LLM apps, chains (sequential steps), agents (reasoning), RAG (retrieval), memory, prompt templates, vector DBs (Pinecone, Chroma), tool calling

GenAI costs: Token-based pricing (input + output), GPT-4 expensive vs GPT-3.5, track usage (tokens/request), rate limiting, caching responses, prompt optimization (shorter = cheaper)

Watch out: Prompt injection attacks, PII leakage, hallucinations, latency (streaming helps), cost explosions (monitoring!), model deprecations, context window limits

18

Easy

0 / 2 points

What is the difference between AI, Machine Learning, and Deep Learning?

AI: Broad field of computer systems performing tasks requiring human intelligence (reasoning, learning, problem-solving)

Machine Learning: Subset of AI where systems learn from data without explicit programming, using algorithms to find patterns

Deep Learning: Subset of ML using neural networks with multiple layers (deep networks) for complex pattern recognition

Relationship: AI ⊃ ML ⊃ DL (each is subset of previous), progression from broad concept to specific technique

🎯 AI Engineer

📋 Candidate Information

📊 Total Score

📋 Interview Report - AI Engineer