Platform Engineer

Sonar Software

9h•Remote

About The Position

Platform Engineers are builders. You take a product requirement, often with a working prototype attached, and turn it into a production-grade system. You design the technical approach, direct agents to build it, and verify what comes back. Then you ship it and keep it healthy once customers depend on it. This role also makes the rest of the engineering org faster. When you solve a problem with an agent workflow, you turn it into something the team can reuse: a skill, a plugin, a quality gate, an automation. Your impact is measured by what you ship and by how much more everyone else ships because of you. This is not a traditional software engineer role with AI bolted on. The lines between software engineering, DevOps and SRE are blurring, and we're hiring for someone who works across all three.

Requirements

3 to 6 years of professional software development, including time supporting what you built in production.
Demonstrated multi-agent orchestration you built and ran on real work. You can walk us through the architecture, what failed, and what you changed.
Hands-on experience writing technical specs that agents and engineers execute against, with acceptance criteria that made verification objective.
A working understanding of evals, guardrails, prompt-injection risk and token/cost tradeoffs in agentic systems.
Strong backend fundamentals, and comfort with relational databases at scale: query analysis, indexing, and migrations against large tables.
Experience with CI/CD, containerized workloads and cloud infrastructure.
Real observability experience. You've built alerts and dashboards that people rely on.
Clear written communication. A lot of this job is writing, for agents and for people.

Nice To Haves

PHP/Laravel, PostgreSQL, Vue.js/TypeScript
Azure, Azure DevOps, Kubernetes, Datadog, ElasticSearch
Queue-heavy systems (Laravel Horizon, Redis)
B2B SaaS with multi-tenant, database-per-tenant architecture
ISP, telecom, billing or OSS/BSS exposure
Experience working closely with product managers to shape requirements into buildable, operable designs

Responsibilities

Build with agents: Design, build and operate multi-agent workflows for real engineering work: implementation, test generation, review, triage and bug remediation.
Decompose work across agents and subagents, and manage context and state between steps.
Design for failure, including retries, timeouts, loops, hallucinated APIs and runaway cost.
Take prototypes from product and harden them into production features. That means sound architecture, real error handling, tests, security, and performance at tenant scale.
Own verification. Agent output isn't done until it's correct, secure, performant and fits the architecture. You are accountable for what merges, not the model.
Know when an agent is the wrong tool, and say so.
Design: Translate product requirements into technical specs. A spec covers architecture approach, data model changes, interfaces, constraints, failure modes, and acceptance criteria that agents can execute against and reviewers can verify.
Keep specs current as the implementation evolves, so the spec stays the source of truth for how the system works.
Push back early when a requirement is technically unsound, carries hidden operational cost, or conflicts with the platform. Bring options, not just objections.
Ship: Own the path to production: pipelines, migrations, feature flags, rollout and rollback.
Take particular care with post-deploy tasks and migrations that run across hundreds of tenant databases.
Treat quality gates as code. Strengthen the checks that keep AI-accelerated change from turning into AI-accelerated incidents.
Run: Ship observability with the feature. Instrumentation, dashboards, alerts and a runbook are all part of done.
Understand how your work behaves under load, including queue backlogs, webhook storms, billing runs and our largest tenants.
Take part in on-call and incident response for what you own, and contribute to blameless RCAs and the follow-up work.
Multiply: Turn one-off agent solutions into shared capabilities other engineers pick up and use: Claude Code skills and plugins, MCP integrations, context files, evals and automation.
Pair with engineers adopting agentic workflows. Document the patterns that work and flag the ones that don't.
Measure the impact of what you build, such as cycle time, cost per change and defect escape, and be honest when it isn't paying off.