Senior Backend Engineer

The Role

We are hiring a Senior Backend Engineer for two platform products:

• Xsolla ID is the identity and authentication platform behind sign-in, account management, and SSO across Xsolla products.

• Xsolla ZK is Web3 wallet infrastructure: smart wallets and account abstraction on a zkSync-based L2.

Both products sit on users' most sensitive flows, logging in and signing transactions, and other Xsolla teams build on top of them.

What You Will Own

• The backend services of your product area end-to-end: design, implementation, release, and production operation, including on-call.

• Architecture across services: service boundaries, integration contracts, and data ownership. You make these decisions and justify them in writing.

• Reliability and security of critical flows: SLOs, failure handling, protection of user data and credentials.

• Service performance and cost under load.

What You Will Do

• Design and build services and APIs (REST, gRPC) for authentication, account management, and wallet operations.

• Define service boundaries and integration contracts with other Xsolla teams.

• Design data models and storage; optimize schemas and queries.

• Build event-driven and asynchronous workflows.

• Own observability: metrics, logs, tracing, and alerting, and act on what production tells you.

• Take part in on-call, incident response, and post-mortems.

• Improve the engineering environment: CI/CD, infrastructure-as-code, testing.

• Review code.

• Set up and maintain AI tooling in the repositories (Claude Code, Codex, Cursor: rules, context, harness) so the team uses it effectively.

Responsibilities

• Language and Platform

  • 5+ years of commercial backend development.

  • Go: idiomatic code, concurrency (goroutines, channels, context, and cancellation), memory, and performance profiling (pprof).

  Data

  • Relational databases (PostgreSQL, MySQL): schema design, indexes, query plans, transactions, and isolation levels, safe migrations.

  • Caching (Redis): when to cache, invalidation, consistency trade-offs.

  Distributed Systems

  • Service architecture and distributed-systems trade-offs: consistency, availability, idempotency, retries, failure modes.

  • Asynchronous messaging and event-driven design (Kafka, RabbitMQ, or NATS): delivery guarantees, ordering, reprocessing.

  APIs

  • Designing REST and gRPC APIs: versioning, backward compatibility, contract documentation (OpenAPI/Swagger, Protobuf).

  Security and Identity

  • Application security: common vulnerability classes (OWASP Top 10), secrets management, safe handling of user data.

  • OAuth 2.0 / OIDC from the server side: flows, tokens, sessions.

  Operations

  • Containers and orchestration (Docker, Kubernetes) at the level of deploying and debugging your own services.

  • Observability (Datadog; experience with Prometheus, Grafana, ELK/Graylog, or OpenTelemetry also counts): metrics, logs, tracing, and alerting; diagnosing incidents in production.

  Engineering Practices

  • Testing: unit, integration, contract.

  • Git, CI/CD (GitLab CI or similar).

  AI-Assisted Engineering

  • Daily hands-on use of AI coding tools (Claude Code, Codex, Cursor) for development and review, including configuring them for a repository.

  English

  • Reading technical documentation in English.

Nice to Have

• Web3 backend experience: blockchain integration, wallet infrastructure, account abstraction.

• High-load systems.

• Cloud platforms (GCP, AWS, or Azure) and infrastructure-as-code.

• NoSQL databases (MongoDB or similar).

• Domain experience in gaming, e-commerce, fintech, or payments.

How We Work

• Decisions in writing. Significant technical decisions are written up as an RFC or ADR that lays out the options and trade-offs. We discuss the document, not a blank whiteboard.

• AI is part of everyday engineering. We use AI coding tools for development and review, and we treat configuring them for a codebase as real engineering work.