Staff Software Engineer, Elixir

Stord•Atlanta, GA

About The Position

Stord is building the operating system for modern supply chain — a unified platform handling Order Management, Warehouse Management, Transportation, and Consumer Experience for brands doing over $10B in commerce annually. The core of that platform runs on Elixir — fault-tolerant, concurrent, and built for the throughput that supply chain operations demand. Keeping it reliable, coherent, and fast as the product evolves and the team grows is not automatic. That is what this role exists to ensure. As a Staff Engineer, you are the technical anchor for your product team. You set the direction, raise the bar, and make the engineers around you more effective. You are not managing people — you are managing the technical trajectory of a team building Elixir systems that directly power Stord's core operations. That means writing code, leading design, shaping the roadmap, and being the person your teammates come to when the problem is hard. This role operates across Stord's core product surface: OMS, TMS , WMS , and Consumer Experience. The systems are distributed, the throughput is real, and the expectations are high. If you want to be the technical force multiplier for a high-output Elixir team working on problems at meaningful scale — keep reading.

Requirements

Elixir / Phoenix / OTP (4+ years, 7+ years total engineering) — Deep, production-hardened expertise in Elixir, Phoenix, and OTP . You have designed fault-tolerant supervision trees, operated distributed systems under real load, and have strong, well-formed opinions about what makes Elixir systems maintainable and safe to operate at scale.
Staff-level technical leadership — Proven track record driving technical direction for a team in production. You have been the go-to Elixir resource before and you know what that actually requires.
Distributed systems & scalable architecture — Experience designing and operating complex, distributed, high-throughput systems in production. You understand the failure modes, the backpressure mechanisms, and the tradeoffs that matter when concurrency is your primary tool.
Event-driven architecture — Deep experience building event-driven systems and working with event streaming platforms (Kafka, Pub/Sub, or equivalent) at production scale.
Database & persistence — Strong SQL fundamentals and experience with PostgreSQL at scale. You model data well and write queries that perform under real load.
Cloud platforms — Hands-on experience with GCP or equivalent. Familiarity with containerization (Docker) and orchestration (Kubernetes).
Observability — You instrument your systems in production and define what good looks like for your team. You know what to measure, how to debug distributed Elixir failures, and how to make production legible to the engineers who are on call.
Directed AI-Assisted Development — You use AI coding tools (Claude Code, Cursor, Codex, or equivalent) as your primary productivity multiplier. You maintain independent technical judgment and produce high-quality results — you do not accept raw model output uncritically. This is a hard requirement.
Ownership & Accountability — You own features end-to-end and take pride in what you ship. You follow through from design to production and don't drop things.
Strong Communication — You can explain technical decisions and trade-offs to engineers, PMs, and stakeholders. You ask good questions and listen well.
Collaborative Approach — You work well with others, give constructive code review feedback, and actively seek input from teammates.
Production Mindset — You prioritize reliability and user impact. You think about failure modes, monitoring, and operational concerns as part of your design process.
Learning Agility — You're comfortable with rapidly evolving AI/ML technologies and tools. You stay current without chasing hype.

Nice To Haves

Experience with Phoenix LiveView, distributed Erlang clusters, and advanced OTP patterns
Experience with event streaming at scale (Kafka, Pub/Sub, or similar)
Familiarity with Stord's broader stack: TypeScript, Kafka, GCP
Experience building or consuming internal developer platforms or shared service infrastructure
Familiarity with agentic AI development patterns (tool calling, MCP , agent orchestration)
Domain knowledge in logistics, supply chain, OMS, TMS , or WMS
Experience with workflow orchestration tools (Temporal, Prefect, Airflow, or similar)
Contributions to open-source Elixir projects or the broader community
Familiarity with frontend technologies (React, TypeScript) — useful for working across integration boundaries
Previous startup or high-growth company experience

Responsibilities

Drive technical direction for your team — ensuring alignment between what is being built, how it is being built, and what the product actually needs.
Identify technical risks early, surface tradeoffs clearly, and push for decisions that hold up at scale.
Lead design reviews and code reviews with the same rigor.
Bring a strong technical perspective into roadmap and planning conversations — influence priorities, not just execution.
Write high-quality, maintainable Elixir across the stack.
Architect and implement scalable, fault-tolerant services that leverage OTP supervision trees, GenServer patterns, and Elixir's concurrency model for real production workloads.
Build and maintain event-driven systems, data pipelines, and integrations that power core product workflows.
Own the performance, reliability, and security posture of your product area.
Work hands-on with GCP and modern infrastructure.
Use AI coding tools — Claude Code, Cursor, or equivalent — as a core part of your development workflow, every day.
Identify opportunities within your product area to introduce agentic workflows that reduce manual toil, accelerate development, and surface intelligence to operators and customers.
Collaborate with the AI and Platform Services teams to consume shared agent infrastructure, skill libraries, and MCP integrations from within the Elixir stack.
Establish patterns within your team for how AI-assisted development is done well — not just adopted, but done with judgment and quality.
Guide junior and mid-level engineers through direct feedback, code review, and design collaboration.
Raise the team's overall technical capability over time — not by gatekeeping, but by making good Elixir and OTP habits contagious.
Be the person who makes other engineers better, not just the person who ships the hardest problems.
Contribute to cross-team technical initiatives alongside other Staff and Principal Engineers.
Participate in the Principal Engineering Group's TDD review process and office hours.
Surface Elixir-specific patterns and decisions that benefit teams beyond your own — and feed back to the Principal Engineering Group when org-wide guidance needs refinement based on what you are seeing in practice.