Senior Backend Systems Engineer

Senior Backend Systems Engineer

Job Description

General Info

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

We are developing a breakthrough imaging and 3D technology platform currently under provisional patent. The Senior Backend Systems Engineer 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 solid 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 experience — cloud infrastructure, CI/CD, infrastructure-as-code, and observability — is a strong plus and part of how the person in this role ships and operates their own code, but the primary focus is the software itself.

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. A senior backend 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.
• At least five years of relevant backend systems, distributed-systems, or platform-software engineering experience.
• 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. Code samples, open-source contributions, or detailed system descriptions in interview will be expected.
• Hands-on production experience deploying and operating your own services, including cloud infrastructure, CI/CD, and observability.

Skills & Competencies

• Solid proficiency in 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.
• Strong 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.
• Solid 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.
• Solid understanding 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.

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

The base salary range for this position is HUF 2,000,000 – HUF 2,500,000 gross per month, paid in twelve monthly installments. The range reflects a full-time, senior-level engagement and is calibrated to the Hungarian market for senior backend systems engineering with hands-on production experience writing high-throughput server software.

The offered starting salary within this range will be determined on the basis of objective, gender-neutral criteria, including the candidate’s demonstrated depth of production C++ on high-throughput server systems, proficiency across Python and bash for service and operational work, breadth of hands-on DevOps and production-operations experience, and track record of shipping and running efficient, scalable server software. Advanced domain knowledge and meaningful contributions in adjacent areas (for example, GPU-based ML inference serving, computer vision or hyperspectral inference, high-volume e-commerce backends, or open-source systems software) are factors that may justify positioning toward the upper end of the range.

In addition to base salary, the total compensation package includes a discretionary performance bonus and statutory and customary benefits as applicable under Hungarian law. Details of the bonus component will be discussed with shortlisted candidates.

This salary range is disclosed in accordance with the pay transparency obligations arising from Directive (EU) 2023/970 and its transposition into Hungarian law. Candidates will not be asked about their prior or current compensation at any stage of the recruitment process.