Staff Backend Engineer

HighLevel; Bengaluru; On-site; INR 4,000,000 - 5,600,000; Full time

Job summary

HighLevel is hiring a Staff Engineer - Workflows (Engine) to own and evolve the orchestration layer powering automation at scale within HighLevel. You'll rewrite the engine that drives 80M+ workflow enrolments per day and nearly 1 billion actions per day at peak with reliability and performance at its core.

You'll operate as a hands-on contributor, designing and writing core engine logic in Go and Node.js while defining contracts and scaling patterns.

Qualifications

• 10+ years of backend engineering experience with distributed systems or orchestration engines.
• Advanced proficiency in Go and Node.js with high-throughput microservices experience.
• Strong testing, isolation, and design for testability in complex systems.
• Production-grade database experience (MongoDB, Firestore or equivalent) and data modelling.
• Cloud experience (GCP, AWS or Azure) with event-driven services.
• Proven performance improvements: latency reduction, throughput gains, reliability.
• Fundamentals in concurrency, idempotency, ordering guarantees and fault tolerance.
• Experience with automation systems and distributed architectures.
• Observability tooling (Grafana, Prometheus, OpenTelemetry) experience.

Responsibilities

• Re-architecture: rebuild the workflow engine to Go, creating a high-performance foundation for billions of executions.
• Core abstractions: design orchestration, state, retries, and execution guarantees with clear contracts.
• Performance model: optimise throughput while maintaining strict per-workflow ordering.
• APIs and contracts: define interfaces between engine, triggers, and actions with versioned communication.
• Reliability and observability: instrument metrics and build replay/diagnostics tooling with SRE.
• Operational ownership: own runtime incidents, RCAs, and reliability improvements.
• Migration and rollout: drive dual-run migration with progressive rollout and safe rollback.
• Engineering culture: set benchmarks for clarity, testability, and performance.

Skills

Go

Node.js

Distributed systems

Back-end engineering

Performance optimization

Microservices

Observability

Cloud experience

Testing / reliability

Tools

MongoDB

Firestore

Grafana

Prometheus

OpenTelemetry

Job description

We're hiring a Staff Engineer - Workflows (Engine) to own and evolve the orchestration layer that powers automation at scale within HighLevel. You'll rebuild the engine that drives 80M+ workflow enrolments per day and nearly 1 billion action executions per day at peak load with reliability, performance, and clarity at its core.

You'll operate as a hands-on individual contributor, designing and writing core engine logic in Go and Node.js while defining contracts, reliability guarantees, and scaling patterns. This is a Staff Architect track role with deep technical ownership, not management. You'll have decision authority on engine architecture and are expected to set the gold standard for how distributed systems are built at HighLevel's automation team.

You'll join the Workflows (Engine) team, a small, autonomous group of top-tier engineers within the Workflows organisation. The team's mission is to build the next-generation orchestration engine that powers all automations at HighLevel: reliable, testable, and ready for future expansion.

This engine handles concurrency, ordering, retries, and scaling under unpredictable load. Your rewrite will make the system more robust, easier to extend with new actions and context types, and dramatically simpler to maintain. Ultimately, your work will enable faster feature delivery across the entire automation platform.

Day to day, you'll work closely with the engineering manager (workflows) and a lead engineer from Workflow Core operating as the founding engineer for the new engine org.

Responsibilities

• Re-architecture: Rebuild the workflow engine from Node.js to Go, creating a modular, high-performance foundation for billions of executions.
• Core abstractions: Design orchestration, state, retries, and execution guarantees with clear contracts and isolation boundaries.
• Performance model: Optimise for throughput-first execution while maintaining strict ordering within each workflow execution context.
• APIs and contracts: Define interfaces and schemas between the engine, triggers, and actions. Ensure consistent, reliable, and versioned communication.
• Reliability and observability: Partner with SRE to instrument metrics (latency, throughput, failure rate) and build replay and diagnostics tooling.
• Operational ownership: Own the engine's runtime incidents, RCA, and prevention. Deliver measurable reliability improvements (< 1% failures/day).
• Migration and rollout: Drive dual-run migration with progressive rollout and auto-rollback safety.
• Engineering culture: Set the technical benchmark for clarity, testability, and performance within workflows and beyond.

Requirements

• 10+ years of backend engineering experience with deep hands-on work in distributed systems, job schedulers, or orchestration engines.
• Advanced proficiency in Go (preferred) and Node.js, with experience writing low-latency, high-throughput microservices.
• Strong understanding of testability and isolation principles; you design systems that are easy to test, reason about, and extend.
• Production-grade database experience (MongoDB, Firestore, or equivalent) with sound data modelling.
• Cloud experience (GCP, AWS, or Azure), especially event-driven services like Pub/Sub, SQS, or Cloud Tasks.
• Proven record of measurable performance wins: reduced p95/p99 latency, improved throughput, or increased reliability.
• Strong fundamentals in concurrency, idempotency, ordering guarantees, and fault tolerance.
• Pragmatic engineering mindset, simplicity and clarity over abstraction for abstraction's sake.
• Strong applied understanding of design patterns and system architecture principles, able to model orchestration, state, and retries using proven, scalable patterns.
• Experience with automation systems (e. g., n8n, Zapier-like architectures) and the ability to generalise such models.
• Observability experience (Grafana, Prometheus, OpenTelemetry, Kibana).
• Strong debugging and performance profiling skills.
• Open-source contributions or technical writing in distributed systems.
• Experience helping define engineering best practices or building early-stage teams.