Senior DevOps Engineer/Platform Engineer

Velora

4d•CA$135,000 - CA$165,000•Remote

About The Position

Velora is looking for a Senior DevOps / Platform Engineer to help run and scale the infrastructure behind Aplos, Raisely, and Keela. This role centers on Raisely (GCP) as our top business priority today, with exposure across all three brands as we unify the platform. This is a DevOps role with a platform engineering focus: building the internal developer platform and paved roads that power how Velora engineering teams build, ship, and operate software (not the product platform itself). We move fast — we're an established, financially solid company, not an early-stage gamble — and we need people who enjoy wearing many hats, adding value, and working shoulder-to-shoulder with the wider engineering org. We hold one of the closest DevOps↔Engineering relationships you'll find anywhere, and that's on purpose. At Velora, DevOps provides the tooling, infrastructure, and processes that let engineers self-serve — safely and at speed. Many engineers have permission to deploy services to production and own everything around them (configuration included) because we’ve built the platform and guardrails that make that safe. We treat our internal developer platform as a product: we partner closely with engineers to understand pain points, requirements, and SDLC needs, then we go build the solutions and operate them. That means DevOps owns core platform evolution work (like upgrades and foundational improvements) so product engineering can keep attention on customer and business problems — while still enabling teams to own services end-to-end. So while the title is DevOps, the person we're looking for is a full-spectrum engineer: someone who understands cloud deeply, provisions and upgrades infrastructure, reasons about networking, memory, CPU, and virtualization — and who can genuinely code, reason about distributed systems, and think through complex workflows. An engineer who chooses to solve DevOps problems.

Requirements

5–9 years in platform engineering, DevOps, SRE, or software engineering, with strong production ownership and cross-team collaboration.
Proven, hands-on software development experience — you've designed, built, and owned production services (backend, and ideally full stack), not just the infrastructure and pipelines around them.
Bachelor's in Computer Science, Engineering, or a related field — or equivalent hands-on experience.
Genuinely strong coding ability. We're language-agnostic, but you can build and reason about real software — internal tools, automation, services — not just glue scripts.
Strong infrastructure-as-code skills with Terraform (we use Terraform Cloud) for provisioning, upgrades, and environment management. This is a strong preference rather than a hard gate.
Solid Kubernetes and Helm experience operating production workloads, with room to deepen on the job.
Cloud fluency with a GCP focus today and the appetite to build expertise across all three major clouds (GCP, AWS, Azure) as we unify the platform.
Comfortable reasoning about distributed systems, service-oriented architecture, networking, and the hardware and virtualization concepts underneath — CPU, memory, and how a running process actually consumes resources.
Working knowledge of databases and transactions — enough to reason about data integrity and trace where a data problem originates.
Architectural instinct for ownership and boundaries — what a component should own, and where the line between Engineering and DevOps sits.
A high bar for technical writing — clear design docs, diagrams, and RFCs.
AI-native by default: you use AI (Claude, Cursor, Notion AI) for everything — troubleshooting, planning, implementation, and execution — and treat "I don't know" as one prompt away from "now I do."
You take a question or task as far as you can yourself, using AI to move confidently into unfamiliar territory, rather than delegating it away — while respecting where another team's ownership begins.
You challenge AI output with rigor — you know when to trust it and when to dig deeper.
You enjoy wearing many hats and thrive in a fast-paced, high-ownership environment.
You own problems end-to-end — figure out the path and ship the outcome, even under ambiguity.
You're obsessed with impact, not activity, and you see DevOps as a force multiplier for engineering, not a gatekeeper.
You give and receive direct feedback — say the hard thing, commit, and move forward.
You think about the business and the team — you invest genuinely in making the people and systems around you better.

Responsibilities

Take end-to-end ownership of our internal orchestration platform — a real SaaS product that DevOps builds and operates, whose customers are Velora's engineering teams. This is a full software stack: a frontend, a backend, a document database, and complex distributed orchestration logic built on an event-driven architecture with Redpanda. Owning it means owning the code, the architecture, and the roadmap — not just running it.
Evolve the platform as a product: understand what engineering needs, design the workflows, and ship the software that delivers them.
Own and evolve our infrastructure-as-code with Terraform (we use Terraform Cloud) — provisioning, upgrading, and managing environments. GCP (Raisely) is the focus initially, with expected exposure to AWS and Azure over time as the person ramps and begins contributing to Terraform for the other brands.
Operate and scale Kubernetes-based workloads with Helm — owning reliability, capacity, networking, and performance for the services you support.
Provide the tooling, infrastructure, and processes that let engineers own their services end-to-end — from deployment through configuration — instead of routing work through DevOps as a ticket queue.
Hold a clear sense of ownership boundaries between Engineering and DevOps: what each component should own, and where one team's responsibility ends and the other's begins. Codify the contract between teams so nothing slips through the cracks.
Partner directly with engineers — reason about distributed systems, data flows, transactions, and webhooks; pinpoint where a problem manifests (in code, in a schema, in a wrong assumption) and hand back a clear diagnosis, without taking over engineering's work.
Own reliability for the platform and services you steward: set sensible SLOs, plan capacity, run resilience drills, and keep systems within target.
Share in production on-call as part of the team — we own what we get paged for, fix what keeps breaking, and keep toil low through automation.
Take ownership during incidents: jump in quickly, drive toward remediation, and run blameless post-incident reviews that produce durable fixes and better runbooks.
Set and drive adoption of modern SDLC patterns — module structure and dependencies, environment promotion, and safe, progressive delivery.
Apply least-privilege IAM, robust secrets management, and image and dependency scanning; bake security into how we provision and deploy.
Author clear design docs, diagrams, and RFCs, and raise the bar for technical writing across the team.
Treat AI as your default operating mode — use Cursor and Notion AI across troubleshooting, planning, implementation, and execution.
Take any problem as far as you can with AI before reaching for help, expanding the surface area you can own without depending on others.