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
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)
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
What is GIL (Global Interpreter Lock)?
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
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
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+)
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
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))
How do you get the dimensions of a DataFrame (pandas)?
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
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
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)
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
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
What is the use case for database transactions?
How would you implement TTL (Time To Live) in PostgreSQL? Without using Redis
What is the difference between the "Repository" and the "Unit of Work" patterns?
Repository: Abstraction over data access (DB), collection-like interface (get(), add(), delete()), encapsulates queries, one repository per entity/aggregate
Unit of Work: Manages transactions across multiple repositories, tracks changes (dirty checking), commit/rollback all operations at once, responsible for consistency
Relationship: UoW contains repositories, UoW = transaction boundary, Repositories = data access, SQLAlchemy Session is essentially UoW, together they form clean architecture
Any data-related experience with platforms like Airflow, Dagster, etc?
Airflow: DAG-based workflow orchestration, task dependencies, scheduling (cron), operators (Python, Bash, SQL), XComs for data passing, monitoring UI, used for ETL/ELT
Dagster: Asset-based (data-aware), type system, testing, backfills, sensors, resources (DB connections), more modern than Airflow, better for data pipelines
Use cases: Daily data loads, ML training pipelines, reporting automation, API data ingestion, data quality checks, orchestrating dbt runs, retry logic, alerting
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
Security - How do you make sure your apps are secure?
Authentication & Authorization: JWT tokens, OAuth2, API keys, RBAC (role-based access), least privilege principle, multi-factor authentication
Input validation: SQL injection prevention (parameterized queries), XSS protection (escape output), CSRF tokens, rate limiting, input sanitization, Pydantic validation
Secrets management: Env variables, vault (HashiCorp Vault, AWS Secrets Manager), NEVER commit secrets, rotate credentials, encrypt sensitive data at rest/transit (HTTPS/TLS)
Dependencies & scanning: Keep dependencies updated (Dependabot), vulnerability scanning (Snyk, Safety), SAST tools, security headers (CORS, CSP), logging & monitoring, penetration testing
How would you protect user passwords while storing to the database? (should be bcrypt or argon2, sha is rather bad, md5 is horrible)
Correct: bcrypt or argon2: Slow hashing algorithms (resistant to brute-force), salt automatic, adaptive (configurable rounds/cost), bcrypt.hashpw() or argon2-cffi
Wrong: MD5, SHA-1, plain SHA-256: Too fast (GPUs = billions hashes/sec), rainbow tables, SHA not for passwords (no salt, not slow), MD5 is completely broken
Best practices: NEVER store plaintext, unique salt per password (bcrypt auto), pepper (application-level secret), password policies (min length, complexity), MFA layer
📊 Celkové Skóre
0%
Začni zaškrtávať odpovede!
📄 Vygenerovať report
🔄 Reset všetkých odpovedí
📋 Interview Report - AI Engineer
📥 Stiahnuť PDF