Sr Backend Engineer

About the role

You'll join Slang's Engineering team as a Senior Software Engineer, contributing across core product areas including telephony infrastructure, real-time voice AI, and application functionality. Your work will help restaurants automate customer interactions and improve service through natural conversation.

You'll spend roughly 90% of your time developing backend services. Our backend is written in Kotlin, but prior Kotlin experience is not required; strong fundamentals in any object-oriented language will set you up to ramp quickly. You'll make occasional contributions to React/TypeScript frontend features as needed. Your work will directly impact thousands of restaurant interactions daily, helping businesses streamline operations and deliver better customer experiences.

You'll report to the Director of Engineering & Data, collaborating closely with product managers, conversation designers, and fellow engineers. As a senior engineer, you'll own features end to end and help shape technical direction for your pod, not just execute against a spec. The role includes key ceremonies: daily standups at 1:00 PM ET, bi-weekly cycle planning, and weekly Show & Tell sessions. You'll use modern collaboration tools like Slack, GitHub, and video conferencing to stay connected with the team. You'll mentor junior and mid-level engineers through code reviews and pair programming, and set the quality bar others build on.

Why you'll thrive

Our engineering culture emphasizes pragmatic solutions, continuous learning, and collaborative problem-solving. We believe in domain-driven design, comprehensive testing, and building systems that gracefully handle the complexities of real-world restaurant operations. You'll work alongside engineers who care about reliable, scalable conversational experiences and who regularly share knowledge through Show & Tell sessions and detailed technical documentation.

As a senior engineer, you'll go deep on conversational AI, telephony at scale, and modern cloud-native architectures while taking ownership of architectural decisions and technical standards. You'll pick up Kotlin and functional programming patterns on the job while working on production systems that handle real-time voice interactions. The cross-functional nature of the role, and the scope you'll own, sets you up to grow toward staff-level and technical leadership work: driving design across services, influencing the roadmap, and raising the bar for the engineers around you.

Responsibilities

• Design and implement scalable backend services following domain-driven design principles, with comprehensive error handling and testing
• Drive technical design for features you own, and help shape architecture across the services your pod touches
• Develop and maintain GraphQL APIs that efficiently serve both internal and external clients
• Create robust integrations with our telephony (Twilio/Telnyx) and voice AI stack, handling edge cases and failure scenarios gracefully
• Design efficient Firestore data models that balance performance, cost, and maintainability
• Implement comprehensive observability including logging, metrics, tracing, and actionable alerting
• Deliver production-ready code with appropriate test coverage (unit, integration, and end-to-end)
• Lead code reviews, providing constructive feedback and raising the quality bar for the team
• Document technical decisions, API contracts, and system architecture clearly
• Deploy containerized applications to Google Cloud Platform following cloud-native best practices
• Occasionally build or update React/TypeScript frontend components for restaurant staff and customers
• Shape coding standards and best practices, and mentor junior and mid-level engineers as they grow

Software Development Scope

• Software Development
  • Design and implement backend services in Slang's backend stack (primary focus)
  • Develop GraphQL queries and mutations for client-server communication
  • Contribute to React frontend components and features as needed
  • Create modular, testable code following domain-driven design principles
  • Implement proper error handling, logging, and graceful degradation patterns
  • Write comprehensive unit and integration tests across the stack
• Data Modeling and Storage
  • Design and implement Firestore data models that optimize for performance and maintainability
  • Create efficient data access patterns and queries
  • Implement data migration scripts and schema evolution strategies
  • Ensure data consistency and integrity across distributed systems
  • Design GraphQL schemas that effectively represent domain models
• Telephony and AI Integrations
  • Develop and maintain integrations with telephony providers (Twilio/Telnyx) for voice and messaging
  • Implement webhook handlers and conversation flows across our speech-to-text, LLM, and text-to-speech pipeline
  • Create fault-tolerant communication between telephony providers and internal services
  • Handle edge cases and error scenarios in real-time voice workflows
  • Implement retry logic and circuit breaker patterns for external service calls
• Frontend Development (as needed)
  • Implement React components using TypeScript
  • Integrate frontend with GraphQL APIs
  • Ensure responsive and accessible UI implementations
  • Write unit tests for React components
  • Collaborate with the product team on user experience improvements
• Cloud Services Integration
  • Develop containerized applications using Docker
  • Deploy and manage services on Google Cloud Platform
  • Ensure services follow cloud-native best practices for scalability and resilience
  • Integrate with GCP services (Cloud Run, Cloud Functions, Pub/Sub) as required
  • Provision new infrastructure using Terraform in partnership with platform engineering
• Observability and Monitoring
  • Implement comprehensive logging, metrics, and tracing
  • Create dashboards and alerts for service health monitoring
  • Develop diagnostic tools to aid in troubleshooting production issues
  • Ensure all services provide actionable insight into their behavior and performance
• Deliverables
  • Production-ready backend code following established coding standards
  • TypeScript/React frontend code when assigned frontend tasks
  • GraphQL schema documentation and query examples
  • Technical design documents for new features and architectural changes
  • Lead and contribute to code reviews for teammates' pull requests, and submit your own code for review
• Testing and Quality Assurance
  • Automated test suites with adequate coverage for backend services
  • Frontend component tests for any UI work delivered
  • Integration tests for all external service dependencies
  • Bug fixes and issue resolution within agreed SLAs
• Collaboration and Communication
  • Participate in daily standups and bi-weekly cycle planning
  • Collaborate with Platform and Data pods on shared initiatives
  • Provide technical input during architecture discussions, and drive design for work you own
  • Share knowledge and progress during weekly Show & Tell sessions
  • Mentor junior and mid-level engineers through code reviews and pair programming
  • Provide regular status updates on assigned work
  • Communicate technical trade-offs and implementation options
  • Document technical decisions and their rationale
  • Participate in cross-functional meetings as needed
• Technical Standards
  • Follow the team's established idioms and best practices for backend development (Kotlin idioms once ramped)
  • Use TypeScript effectively with proper type safety for frontend work
  • Use dependency injection and maintain loose coupling
  • Write self-documenting code with meaningful variable and function names
  • Maintain consistent code formatting using agreed-upon linters

Engineering Values

How we work matters as much as what we build. Four values guide the engineering team at Slang:

• Start Less, Finish More — Focus is a choice. We ruthlessly prioritize, ask "why" before committing, and say no early so we ship meaningful work instead of accumulating half-finished efforts.
• Teamwork & Collaboration — Great engineering doesn't happen in isolation. We share knowledge and load, assume best intentions.

Requirements

• 5+ years of professional software development experience, primarily in backend systems
• Strong proficiency in at least one object-oriented language (e.g., Java, Kotlin, C#, Python, TypeScript, Ruby, C++, Go), with a solid grasp of OO design principles and willingness to work day-to-day in Kotlin
• A track record of owning features end to end and mentoring less-experienced engineers
• Experience building and consuming RESTful or GraphQL APIs
• Familiarity with NoSQL databases and data modeling concepts
• Experience with containerization (Docker) and cloud platforms (GCP, AWS, or Azure)
• Strong understanding of software testing practices and test-driven development
• Excellent debugging and troubleshooting skills
• AI fluency: you actively use AI tools in your daily engineering work, not just awareness of them. We're AI native, and we expect the same of our engineers
• Basic familiarity with React and TypeScript (occasional frontend adjustments may be needed)
• Ability to work independently and manage your time effectively in a remote/hybrid environment
• Strong written and verbal communication for remote/hybrid collaboration
• Willing and able to take a week-long on-call shift roughly every two months

Preferred Qualifications

• Experience with Kotlin, Java, or another JVM language, and familiarity with functional programming concepts
• Familiarity with GraphQL schema design and implementation
• Experience with Google Cloud Platform services (Firestore, Cloud Run, Cloud Functions, Pub/Sub)
• Knowledge of telephony systems (Twilio, Telnyx, or similar) and webhook integrations
• Experience with real-time voice or conversational AI (speech-to-text, LLM orchestration, text-to-speech)