You have opted out of job matches in .
To undo this, go to the 'Skills and Interests' section of your preferences.
Posted 3 months ago
Requirements and responsibilities
We are looking for a Senior Backend Engineer (Python) at the Architect / Team Leader / Principal Engineer level to collaborate with our Customer.
Project:
- The project is being carried out for a German client and involves building an evaluation platform — a key system enabling the testing of AI agents through simulated scenarios and monitoring of performance results.
Role in the Project:
- The Senior Python Backend Engineer will collaborate with an internal development team and technical leads.
- The role includes full ownership of building and developing solutions and deploying them to production environments.
- Microservices must be high-performance, low-latency, scalable, and reliable.
Candidate Expectations:
- A combination of deep Python knowledge with system design skills, architectural thinking, independence, and proactivity.
- Strong sense of ownership.
- Strong communication skills.
- Independence in designing and evolving system architecture.
- These solutions directly impact the quality of experience for customers testing and deploying AI agents at scale.
Collaboration Model:
- Contract through end of 2026 with a high likelihood of extension.
- Remote work (100% FTE).
- Project team of 4–5 people based in Poland.
- Occasional visits to the Berlin office possible.
Team Office Meetings:
- The team meets in Berlin approximately once a month, or a few days per quarter; the schedule is flexible.
- Part of the team works from the UK and also joins these meetings.
- Travel expenses are covered by the company.
- Attendance is not mandatory but is appreciated for collaboration and team building.
Requirements:
Python and Backend:
- Strong knowledge of modern Python, at least 3 years of experience with versions 3.10 and above (asyncio, concurrency, asynchronous programming).
- Experience building backend services running in production environments, 7+ years expected.
System Design and Maintenance:
- Designing and implementing REST APIs.
- Designing scalable distributed systems.
- Experience with event-driven architecture or task queue-based systems.
- Designing fault-tolerant and overload-resistant systems.
- Experience maintaining production systems.
Data Processing and Persistence:
- Production experience with databases (NoSQL, MongoDB preferred).
- Data modeling, schema management, migrations.
- Query and database structure optimization.
Concurrency and Task Processing:
- Background task processing architecture.
- Handling long-running and parallel tasks.
- Worker models and process isolation.
Engineering Ownership and Communication:
- End-to-end ownership of delivered solutions — from analyzing and verifying requirements, designing architecture, through to production deployment.
- Ability to make technical decisions, analyze and address risks.
- Good English communication skills.
Nice to Have:
Python Ecosystem:
- FastAPI or other async web frameworks.
- Pydantic and type-based validation.
- Static type checking (mypy).
Distributed and Event-Driven Systems:
- Kafka or similar streaming systems.
- Task queuing and load distribution systems.
- Multi-tenant system design.
Cloud and Containerization:
- Kubernetes and container deployments.
- CI/CD and deployment automation.
System Observability:
- Distributed tracing systems (e.g. OpenTelemetry).
- Metrics-based monitoring and SLOs.
Performance and Scaling:
- High-throughput systems.
- Load balancing and queue sharding.
AI / LLM Integrations:
- Integration with language model APIs.
- Designing evaluation and scoring pipelines.
- Managing rate limits and model query costs.
Work Environment and Tooling:
Backend and Infrastructure:
- FastAPI, Uvicorn, httpx.
- MongoDB (Motor).
- Redis (task queues).
- Kafka / Azure Event Hubs.
- Kong as middleware layer for LLM integrations.
Observability and Monitoring:
- OpenTelemetry.
- Datadog.
- Structured logging and trace correlation.
Delivery and Infrastructure:
- Kubernetes and Helm.
- Docker (multi-stage builds).
- GitHub Actions (CI/CD).
- ArgoCD (GitOps).
Python Tooling:
- UV (dependency management).
- Ruff, mypy.
- Pytest, testcontainers.
AI Integrations:
- OpenAI SDK and structured model responses.
- LLM Gateway architecture.
- Token usage and rate limit control.
Optionally, you can add more information later (benefits, pre-screening questions, etc.)