Mid Level Backend Engineer

We're building an AI-powered live coaching platform that helps sales teams improve.

We're looking for a fast-moving, AI-native Mid-Level Backend Engineer who can deliver production-ready features quickly using modern development tools (Cursor, VibeCoding).

This role is designed to complement our senior engineering team: you'll own feature implementation, API development, and integration work while learning from senior engineers on architecture and system design, you'll work directly with the tech leads; when we do, you'll be their primary implementation partner, with perspective to be quickly be prompted based on your results.

🌕 About Yolk

Yolk is a VC-backed startup (Investors of Anthropic, Groq, Tentsornet) on a bold mission: To build the best sales departments in the world with elite AI coaching available to every team. Our AI sales coach helps revenue teams catch deal-killing mistakes before they hit your forecast—sharpening discovery, objection handling, negotiation, and more. We’re not just replacing traditional corporate training; we’re lifting win rates, shortening ramp, and unlocking millions in new revenue. Being the #1 AI coach is big. That’s where you come in.

What You'll Build (Key Engineering Work)

Feature Implementation & API Development

• Build FastAPI endpoints for admin dashboards, user management, training sessions, and insights
• Implement business logic for quota tracking, usage limits, and access control
• Design database schemas and write efficient SQLAlchemy queries for new features
• Create RESTful APIs that frontend teams can integrate quickly

Integration & Data Processing

• Build adapters for third-party services (Gong, Fireflies, Stripe, Apollo, Resend)
• Implement background workers for email automation, transcript processing, and data synchronization
• Write LLM integration code for transcript analysis, structured outputs, and content generation
• Handle webhook processing and event-driven workflows

Quality & Reliability

• Write integration tests that exercise full request/response cycles
• Implement error handling, retries, and idempotency for critical operations
• Add observability instrumentation (metrics, logging) following established patterns
• Ensure data integrity and proper transaction handling

AI-Accelerated Development

• Use Cursor/VibeCoding to rapidly explore codebases, generate boilerplate, and implement patterns
• Leverage AI tools to write tests, refactor code, and understand complex systems
• Maintain code quality while moving fast — you understand what the AI generates

Tech StackCore: Python 3.12+ | FastAPI | SQLAlchemy 2.0 (async) | PostgreSQLAsync & Messaging: RabbitMQ + FastStream | WebSockets | Redis (optional)Infrastructure: Kubernetes (EKS) | Helm | Docker | AWSAI & Real-time Audio: OpenAI/Anthropic APIs | Pipecat (real-time audio pipelines)Observability: OpenTelemetry | Prometheus | SentryTooling: uv | ruff | basedpyright (strict) | Cursor/VibeCoding
 

You Own:

• Feature implementation from spec to production
• API endpoint design and business logic
• Database operations and query optimization
• Integration code and third-party adapters
• Test coverage and quality assurance
• Using AI tools to accelerate development

Senior Engineers Own:

• System architecture and design patterns
• Complex state management and real-time systems
• Performance optimization and scalability
• Observability infrastructure and debugging tools
• Mentorship and code review

Together You:

• Senior designs the architecture → You implement it
• Senior establishes patterns → You follow and extend them
• Senior optimizes performance → You write the code that benefits
• You ship features → Senior ensures they scale

You Should Have

Must-Have:

• 2-4 years backend engineering experience, or strong portfolio from top CS program
• Solid Python fundamentals with experience in async/await
• Experience with FastAPI or similar web frameworks
• Understanding of PostgreSQL and ORMs (SQLAlchemy experience preferred)
• Fast learner: You can pick up new technologies and patterns quickly
• AI-native development: You actively use Cursor, GitHub Copilot, or similar tools to accelerate development while maintaining code quality
• Strong fundamentals: Data structures, algorithms, system design basics
• Production mindset: You think about error handling, edge cases, and user experience

Highly Valued:

• Experience with async Python (asyncio, async/await)
• Familiarity with message queues (RabbitMQ, Redis, etc.)
• Understanding of REST APIs and API design
• Experience with Docker and containerized applications
• TypeScript/JavaScript experience (helps with frontend collaboration)
• Git workflow proficiency (branching, PRs, code review)
• Experience with LLM APIs (OpenAI, Anthropic) — even if just experimenting
• Understanding of testing frameworks (pytest)

Nice-to-Have:

• Kubernetes or cloud deployment experience
• Contributions to open-source projects
• Experience with email services (Resend, SendGrid, etc.)
• Understanding of usage-based billing systems
• Background in sales tech / RevOps domain

What We're Looking For

We need someone who:

• Ships fast: You can take a feature from spec to production quickly with high quality
• Uses AI tools effectively: You leverage Cursor/VibeCoding to write boilerplate, generate tests, explore codebases, and implement patterns — but you understand what the code does
• Learns by doing: You're comfortable diving into unfamiliar code and asking questions
• Writes clean code: Your code is readable, well-structured, and follows established patterns
• Collaborates well: You communicate clearly, take feedback, and contribute to code reviews
• Handles ambiguity: You can work from product requirements and make reasonable implementation decisions
• Complements senior engineers: You're comfortable implementing designs rather than making architectural decisions

Growth Path

Immediate (Months 1-3):

• Ship features independently with clear requirements
• Build APIs and integrations following established patterns
• Use AI tools effectively to accelerate development
• Learn our codebase and domain

With Senior Engineer (Months 3-6):

• Implement features designed by senior engineers
• Learn system design and architecture patterns
• Contribute to code reviews and technical discussions
• Take on more complex features with mentorship

Long-term (6+ months):

• Own larger features end-to-end
• Contribute to architectural discussions
• Mentor junior engineers (if we hire)
• Specialize in areas you're passionate about

How We Work

• AI-accelerated development: We use Cursor and modern AI tools to move fast — you should too
• Pragmatic architecture: We adapt complexity to the problem — simple endpoints for simple features
• Integration-first testing: We favor full-stack integration tests that exercise the real request/response lifecycle
• Modern Python tooling: uv for package management, ruff for linting, strict type checking
• Mentorship: You'll work closely with senior engineers (or CTO/tech lead) who will help you grow
• Fast iteration: We ship features weekly and iterate based on feedback

What We Offer

• Work on genuinely interesting technical challenges (real-time AI, audio processing, distributed systems)
• Fast-paced learning environment with mentorship from senior engineers
• Modern tech stack and tools (including AI coding assistants)
• Direct impact on product features that ship to enterprise clients
• Clear growth path as the team scales
• [Compensation / equity / benefits — customize as needed]

Interview Process

• Technical screen (45 min): Python fundamentals and async concepts
• Coding session (90 min): Build a small FastAPI endpoint with AI tools available (we want to see how you use them)
• System walkthrough (60 min): Explore our codebase together, discuss how you'd approach a feature
• Team fit (45 min): Culture and collaboration

Ideal Candidate Profile

• Top CS graduate with strong fundamentals
• 2-3 years professional experience, or exceptional portfolio
• AI-native: You've used Cursor/VibeCoding extensively and understand their strengths/limitations
• Fast and quality-focused: You ship quickly but don't cut corners on code quality
• Curious and collaborative: You ask questions, seek feedback, and contribute to team discussions
• Implementation-focused: You're excited to build features, not necessarily design systems (yet)