Software Engineer (Backend)

• As a Software Engineer at Normal, you will build the backend runtimes and distributed systems behind our AI products. You’ll design orchestration services, execution environments, internal APIs, persistence layers, and observability systems that allow AI agents to perform long-running work reliably
• These systems coordinate workloads across distributed environments, execute code and tools securely, preserve state across long-running sessions, and recover cleanly from failures. Your work will turn ambitious AI prototypes into dependable products used in real customer workflows
• The role spans backend, AI, and platform engineering. Its focus is the application and runtime layer but not general-purpose cloud infrastructure or company-wide developer operations. You’ll work closely with product, AI, research, and platform engineers to define the interfaces between AI capabilities, execution environments, and production services
• On any given day, you might design the execution model for a new AI capability, build an orchestration service for autonomous workflows, improve the scheduling and isolation of distributed workloads, or create an API that makes a complex runtime capability easy for other engineers to use
• Runtime and Orchestration: Build the services that manage agent execution, session lifecycles, long-running workflows, and distributed workloads
• Backend Systems and APIs: Design reliable services, data models, and internal APIs used by product engineers, AI engineers, and execution systems
• State and Failure Handling: Develop clear models for persistence, retries, queues, leases, cancellation, recovery, and other distributed-systems concerns
• Execution Environments: Build software that schedules and manages containerized workloads in Kubernetes-backed environments, including lifecycle, isolation, autoscaling, and resource management
• Reliability and Observability: Make evolving systems easier to operate through thoughtful metrics, tracing, debugging tools, and well-defined failure modes
• Developer Experience: Create abstractions and tools that allow other engineers to extend the platform without needing to understand every underlying implementation detail
• Prototype-to-Production Engineering: Turn promising prototypes into durable systems by clarifying boundaries, hardening critical paths, and introducing operational patterns that scale
• Technical Design: Lead design discussions around runtime architecture, API boundaries, state management, execution models, and operational tradeoffs

Preferred experience

• Experience operating production services where reliability, observability, maintainability, and performance matter
• Pragmatic judgment about when to invest in a durable abstraction and when to ship the straightforward version
• Range: you have gone deep in at least one area and can become productive in an unfamiliar codebase or technical domain
• A product mindset: you care whether the system is understandable and dependable for the people using it, not only whether the code is correct
• 4+ years of software engineering experience and a track record of shipping backend systems that other people depend on
• The ability to debug across boundaries—from a client or CLI through services, databases, and deployment infrastructure
• Comfort reasoning about distributed failure modes such as retries, partial completion, duplicate work, cancellation, and recovery
• Experience designing APIs and data models, and reasoning clearly about concurrency and state
• Postgres, Redis or Valkey, event-driven architectures, or high-volume stateful services
• Developer tools, CLIs, workflow engines, job schedulers, or distributed execution systems
• Kubernetes, containers, cloud infrastructure, or deploying software in resource-constrained, on-premises customer environments
• Semiconductors, EDA, or hardware engineering workflows