Senior Backend Engineer

Responsibilities:

• Design, build, and run scalable backend services in Go across the product surface (not a single narrow service).
• Own the API layer used by web and mobile: consistent REST-style JSON APIs, versioning, error handling, pagination, and backwards compatibility as clients evolve.
• Authentication and authorization: robust auth flows, tokens/sessions, and fine-grained permission models (including roles that depend on context, e.g. which property or unit someone is acting on).
• Data modelling and databases: PostgreSQL schemas, migrations, integrity, and performance; sensible use of Redis for caching, rate limiting, or short-lived state where appropriate.
• Billing and integrations: subscriptions, invoices, and third-party payment webhooks with emphasis on idempotency, retries, and auditability.
• Cross-cutting platform concerns on an API gateway or edge layer: routing, auth validation, rate limits, and resilience when talking to downstream services.
• Async and real-time patterns where the product needs them: notifications (email, SMS, push), and event-style or streaming patterns for alerts and activity feeds.
• File and media flows: secure uploads/downloads, object storage patterns, and access rules that match who is allowed to see what.
• Production discipline: structured logging, metrics, tracing, tests (unit and integration), and participation in on-call-style troubleshooting and post-incident follow-up.

Requirements:

• Several years of professional experience building backend services in Go in production.
• Solid grasp of concurrency in Go (goroutines, channels, context cancellation) and how to avoid subtle failure modes under load.
• Experience designing and maintaining HTTP APIs consumed by more than one client (e.g. web and mobile).
• Strong PostgreSQL skills: modelling, migrations, constraints, and performance-aware queries.
• Authentication experience (e.g. JWT, OAuth2, where relevant) and authorization beyond a single global role, comfortable with contextual or multi-tenant permission rules.
• Redis is used for something other than a tutorial (sessions, cache, rate limits, pub/sub, etc.).
• Docker and Kubernetes (or close equivalent); ability to read deployment configs and reason about networking, secrets, and rollouts.
• Familiarity with at least one major cloud provider (AWS or GCP) and common building blocks (compute, databases, object storage, secrets).
• Habit of writing automated tests and shipping observable systems (logs, metrics, traces).
• Ownership: you take problems from ambiguous requirements to documented behaviour, tested code, and a clear story for operations, not only tickets that stop at “merged.”
• Strong written and spoken communication; comfortable in async and in small, fast-moving teams.
• Experience owning or heavily influencing a gateway or edge layer in front of multiple services.
• Billing or payments-adjacent work: webhooks, duplicate protection, reconciliation, subscription lifecycle edge cases.
• Message queues or brokers and reliable event-driven patterns (outbox, idempotent consumers, dead-letter handling).
• Property technology, access control, or multi-tenant B2B products where permissions and data isolation get complex.
• Early-stage or greenfield experience where you balanced speed with systems that had to last.
• Exposure to OpenAPI (or similar) and contract-driven coordination with frontend teams.

What success looks like:

• Production issues can be traced end-to-end (edge → service → database or integration) and fixed with tests and a safe rollout.
• Permission and billing changes do not create silent inconsistencies between apps or user types.
• New capabilities ship with clear API contracts, monitoring, and a plan for failure modes, not only the happy path.