Senior Software Engineer - Server Infrastructure

Job Description

This position is on-site in Budapest and requires EU residency and EU work visa.

General Info

We are building a computational imaging platform that recovers the physical optical properties of a scene — the illumination, the camera’s own response, and how real materials reflect and scatter light — from ordinary consumer camera capture. This is a difficult, high-impact engineering problem, and we are building the whole stack: capture, models, and the applications that run on them. The first keystone component is under provisional patent, with a broader patent family in progress.

The Senior Software Engineer - Server Infrastructure builds and maintains the production server software that delivers this platform to end users — the high-throughput API backend, the ML inference gateway that serves our models, and the internal control-plane services that hold the whole system together. Our technology is developed and trained on our on-premises GPU cluster; this role is responsible for the software that takes those trained models and our product experiences and serves them reliably to hundreds of thousands of concurrent users.

This is, first and foremost, a software engineering role. The person in this position writes expert-level production C++ on the hot paths where throughput, tail latency, and memory behavior are first-class product attributes; writes the Python services where development velocity, clarity, and integration breadth matter most; writes the bash and shell tooling that automates build, deployment, and operational tasks; and designs the concurrency, I/O, and state-management strategies that let live user connections survive instance failure, rolling deployment, and capacity rebalance without the end user noticing. The role exists because shipping an imaging and ML platform at scale requires server software written deliberately, not assembled from configuration.

This is a hands-on, high-ownership senior role focused on writing efficient, scalable server software. DevOps depth — cloud infrastructure, CI/CD, infrastructure-as-code, and observability — is not a peripheral skill here; it is how the person in this role ships and operates their own code. The primary focus remains the software itself.

We will be candid about the bar, because it is the whole point of this posting. This role sits at an intersection very few engineers actually occupy: real C++ performance-engineering ability, genuine distributed-systems and cloud judgement, hands-on DevOps competence, and an appetite for the deeply technical, unglamorous work of making an ML imaging platform serve hundreds of thousands of concurrent users without flinching. Most strong backend engineers have two of those, and passing familiarity in the other two is not what we mean. We are looking for the rare person with real depth in all four who finds the combination interesting rather than exhausting.

If that is you, there are few places where the problem is this hard, the ownership this complete, or the technology this new: you would be the engineer who defines how this platform is served, not one of many maintaining someone else's decisions. This is a role for someone who still writes the critical code personally and wants to, not for an architect who directs it from a distance. We would rather leave this seat open until we find the right person than fill it twice.

Tasks

Server Software & Performance Engineering

• Design, write, and maintain the production server software that runs the Company's platform: the API backend that serves the website, mobile, and e-commerce traffic; the ML inference gateway that fronts our GPU-backed model serving; and the internal control-plane services that coordinate them.
• Write the performance-critical code paths in modern C++ — the request hot paths where latency budgets are measured in milliseconds, the dispatch and batching logic where efficiency depends on careful queueing, and the data paths where allocation behaviour and memory layout determine whether the system meets its throughput targets.
• Write the Python services that surround and complement the C++ core — control-plane logic, integration glue, request orchestration, and the parts of the stack where development velocity and clarity matter more than raw performance.
• Write the bash and shell tooling that automates build, deployment, data movement, and routine operational tasks, and keep that tooling reliable and maintainable.
• Design and implement graceful connection and session migration so that live user connections survive instance failure, rolling deployment, and capacity rebalance — handed off to healthy instances without the end user perceiving an interruption.
• Maximize throughput and minimize tail latency at the hot paths through deliberate, justified choices in concurrency model, non-blocking I/O strategy, memory and allocation behaviour, serialization format, and batching. Treat response time as a product attribute, not an operations metric.
• Profile, diagnose, and optimize performance end-to-end — from CPU and GPU utilization through network and storage paths — and fix root causes in the server code rather than working around them in infrastructure.

ML Inference Serving

• Contribute to the inference gateway as a software engineering problem: request batching, GPU memory management, model versioning, request-level latency budgets, and graceful degradation under overload.
• Support the training-to-serving handoff in partnership with the ML team: model packaging and artifact format, staged rollouts and version pinning, and the operational contract between the on-premises training cluster and the cloud serving tier.
• Build inference-time observability — request-level traces and per-model latency telemetry — so model performance is debuggable in production and inference regressions can be investigated quickly.

Platform & Cross-Functional Collaboration

• Work within the service boundaries, deployment patterns, data and caching layers, and performance constraints of the platform, and contribute to their evolution for the website, e-commerce, and mobile API backend.
• Partner closely with the Mobile Software Engineer on the mobile API backend — authentication, data synchronization, media upload and download, offline-capable request patterns, and the latency and reliability contract that the mobile client depends on.
• Integrate with third-party systems: e-commerce engine, product-supply and fulfilment systems, payment processors, and communication services.
• Contribute to the data architecture: operational databases, caches, object storage, analytics pipelines, and the movement of data between on-premises and cloud environments.

Infrastructure & Operations

• Deploy, operate, and reason about the systems you write. You are responsible for your code in production, including its observability, its failure modes, and its cost. An engineer who can run their own code in production is exactly what this role is asking for.
• Work fluently with cloud infrastructure (AWS or equivalent) — compute, networking, storage, identity, and the operational surface — to deploy your services and the platform around them. Use infrastructure-as-code (Terraform or equivalent), container orchestration (Kubernetes), and CI/CD pipelines as engineering tools.
• Establish the observability practices for your code: meaningful metrics, structured logs, distributed traces, and dashboards that make production behaviour intelligible. Define service-level objectives for the services you own.
• Participate in the on-call rotation for the systems you build, and help drive incident response when something you own breaks in production. Blameless postmortems and follow-through on remediation are part of the role.

Collaboration & Craft

• Contribute to architecture and design discussions for backend systems and ML serving, review proposals from teammates, and push back constructively to raise the bar for production quality.
• Mentor less-experienced engineers through code review, design review, and pair-programming on hard problems. This is a hands-on individual-contributor role, not an engineering management role.
• Maintain architectural documentation, design records, and operational runbooks as living, accurate artifacts — not write-once shelf-ware.

Requirements

Education & Experience

• Master's degree in Computer Science, Software Engineering, or a related technical field, from a top-tier programme, with a strong academic record. Exceptional candidates whose production track record clearly exceeds their credentials will also be considered.
• At least five years of relevant backend systems, distributed-systems, or platform-software engineering experience, with clear evidence of operating at the top of that field rather than simply having spent the time in it. We want engineers who are still deep in the code every day and whose skills are thoroughly current.
• Demonstrated track record of having personally written significant portions of at least one high-throughput production server system — not having only operated one that someone else wrote. Substantial code samples, open-source contributions, or a detailed system walkthrough in interview will be expected, and we will go deep on them.
• Hands-on production experience deploying and operating your own services, including cloud infrastructure, CI/CD, and observability.

Skills & Competencies

• Expert-level, thoroughly current command of modern C++ (C++17 or later) for production server software — concurrency primitives, non-blocking I/O, memory and allocation behaviour, and the discipline to write C++ that is fast and correct under sustained production load.
• Expert-level proficiency in Python for service implementation, control-plane logic, and integration tooling. The ability to choose deliberately between C++ and Python for a given component, and to make the two interoperate cleanly, is part of the job.
• Comfortable and effective in bash / shell scripting for automation, deployment, and day-to-day operational work in a Linux environment.
• Deep, first-principles understanding of high-throughput, low-tail-latency server design: concurrency models, event-loop and threaded architectures, connection and session state management, backpressure, graceful degradation, and transparent failover across instances.
• Strong DevOps experience is a significant plus: cloud infrastructure (AWS preferred; GCP or Azure acceptable), infrastructure-as-code (Terraform or equivalent), container orchestration (Kubernetes), and CI/CD pipelines used confidently as everyday engineering tools.
• Experience with GPU-based ML inference serving — request batching, GPU memory management, model versioning, and the latency-versus-throughput tradeoffs specific to inference workloads — is a strong plus. Familiarity with serving frameworks (Triton, TorchServe, custom) is welcome, but the ability to reason about inference serving from first principles matters more than experience with any particular framework.
• Strong command of modern observability practice — metrics, structured logs, distributed traces, and the discipline of designing for debuggability rather than retrofitting it.
• Additional fluency in Go or Rust is a plus, particularly for systems-software work where the C++/Python split is not the right answer.
• Ability to handle confidential and pre-patent technical material with discretion, and to follow the Company's IP and data-handling policies rigorously.
• High degree of curiosity, craftsmanship, and resilience; calm and methodical under production pressure.
• Genuine interest in this specific problem. The work is niche by design — GPU-backed inference serving for a novel computational imaging platform — and the engineers who thrive here are the ones who find that specificity attractive rather than narrow.

Additional Preferred Experience

• Experience designing or shipping inference serving infrastructure for computer vision, hyperspectral, or other high-data-volume model classes — where bandwidth, batching, and GPU memory layout dominate the engineering.
• Experience with hybrid architectures spanning on-premises GPU clusters and cloud serving — model export, artifact management, and the training-to-serving handoff.
• Open-source contributions to backend systems, distributed-systems, or ML serving infrastructure.
• Experience with high-volume transactional backends, payment integration, or multi-region resilience engineering.

Candidates must be eligible to work in Hungary, with fluent English knowledge, both written and oral.

Compensation

In accordance with Hungary’s implementation of the EU Pay Transparency Directive (Directive (EU) 2023/970):

• Salary range: HUF 2,500,000 – HUF 4,000,000 gross per month, depending on experience and demonstrated depth. The upper half of this range is reserved for candidates who clearly meet the full bar described above.
• Discretionary performance bonus, with details discussed with shortlisted candidates.

Compensation decisions are made on the basis of objective, gender-neutral criteria, including relevant experience, technical skills, scope of responsibility, and demonstrated performance. The Company does not request salary history during the recruitment process.