Backend Engineer

Feature Flags Team

  • Location

    Remote (US)

  • Timezone(s)

    GMT+ 2:00 to GMT -8:00

About PostHog

We equip every developer to build successful products.

We started with open-source product analytics, launched out of Y Combinator's W20 cohort.

We've since shipped more than a dozen products, including a built-in data warehouse, a customer data platform, and Max AI, an AI-powered analyst that answers product questions, helps users find useful session recordings, and writes custom SQL queries.

Next on the roadmap are messaging, customer analytics, ai task creation and coding based on customer data, logs and support analytics.

Our values are not a poster on the wall full of aspiration. They’ve come from how we really work, day in day out.

PostHog is open source product led, and a default alive company that is well funded.

Who we’re looking for

We're seeking a high-performance backend engineer for our Feature Flags team (led by Dylan Martin) who thrives on the challenge of building systems that need to respond in single-digit milliseconds at scale. You're the type of engineer who gets excited about profiling applications, getting clever with data access patterns, shaving microseconds off response times, and designing elegant systems that can handle millions of requests per minute without breaking a sweat.

The ideal candidate has experience with high-throughput, low-latency services similar to:

  • Real-time bidding platforms

  • Payment processing systems

  • Recommendation engines

  • Authentication services

  • Content delivery networks

You're not just a performance optimizer - you care deeply about clean architecture, observability, and creating APIs that developers love to use and applications rely on. You understand that in the feature flags world, your code is in the critical path of every customer's user experience, and you take that responsibility seriously.

What makes this role unique

Unlike many high-scale API engineering roles where you're maintaining a small part of a massive system, at PostHog you'll:

  • Own the entire service from end-to-end: Design, build, deploy, and scale the feature flags evaluation engine.

  • Build in the hot path with real impact: Your code runs in the critical path of our customers' applications, making a direct impact on their user experience.

  • Start from first principles: Scale up new services from the ground up rather than just maintaining existing infrastructure.

  • Set your own performance targets: You won't be constrained by other teams' requirements - you'll define and own the latency goals that make our customers successful.

  • See immediate results: Deploy optimizations and see the impact on performance metrics in real-time.

  • Work with cutting-edge tech: Most of our performant stuff (e.g. our flags evaluation endpoint) is written in Rust (Dylan wrote a great blog post about it!), while our application layer uses Python/Django.

What you'll be doing

Our engineering team is distributed across the Americas, and we are open to candidates based anywhere in GMT-8 and GMT+2 time zones. You'll collaborate with a distributed team that's passionate about building world-class developer tools.

We're growing very quickly at PostHog, and our Feature Flags service is scaling rapidly. You'll be responsible for building and maintaining our feature flags evaluation engine that makes complex decisions based on person/group properties at high speed and scale.

We recently rewrote the service in Rust (yep, that’s the same blog post again, it’s really worth a read 😅) and are working on adding new targeting features and continuing to improve the latency. You'll be working on a critical part of our infrastructure that customers rely on for real-time feature delivery. One day, you'll be making high-level architecture decisions, the next you'll be optimizing a performance bottleneck that slashes latency by 50%, and the day after you'll work directly with customers to implement complex targeting rules that meet their specific needs.

You’ll fit right in if:

  • You have experience with any systems programming language and/or backend web frameworks. We use Python and Rust a lot – our app is written in Django, and the flags evaluation API is written in Rust – so experience in those languages is a plus, but not required

  • You’ve built systems that handle high volumes of requests/data (millions+ per minute)

  • You can choose a sensible architecture quickly, and then ship it faster than other people think is possible

  • You have a strong understanding of performance optimization techniques, caching strategies, and distributed systems principles

Nice to have

  • You worked with feature flag systems or similar real-time decision engines

  • You actively participated in on-call rotations, and have dealt with and resolved production incidents

  • You're comfortable with provisioning, tuning, and deploying infrastructure

  • You worked with benchmarking and profiling tools

  • You have a solid understanding of observability systems and practices

What’s in it for you?

Now that we've told you what you'll be building with us, let's talk about what we'll be building for you.

Meet the Feature Flags Team

Ship boldly. Roll out wisely. Scale from first deploy to billions of evaluations. Drop-in SDKs, intuitive flag management UI, zero friction – we build feature flags that never slow you down.

Team members

Does pineapple belong on pizza?

60% say NO!

We have a set system for compensation as part of being transparent. Salary varies based on location and level of experience.

Learn more about compensation

Location

(based on market rates)

Level

Step

Salary calculator

  1. Benchmark (United States - San Francisco, California) $243,000
  2. Level modifier 1
  3. Step modifier 0.95 - 1.04
Salary $230,850 - $252,720+ significant equity
We are open to paying well beyond these ranges for exceptional talent. If this is you, please apply.

  • Generous, transparent compensation & equityGenerous, transparent compensation & equity
  • Unlimited vacation (with a minimum!)Unlimited vacation (with a minimum!)
  • Two meeting-free days per weekTwo meeting-free days per week
  • Home officeHome office
  • Coworking creditCoworking credit
  • Private health, dental, and vision insurance.Private health, dental, and vision insurance.
  • Training budgetTraining budget
  • Access to our Hedge HouseAccess to our Hedge House
  • Carbon offsettingCarbon offsetting
  • Pension & 401k contributionsPension & 401k contributions
  • We hire and pay locallyWe hire and pay locally
  • Company offsitesCompany offsites

Get more details about all our benefits on the Careers page.

Q4 2025 Objectives

This quarter we're making feature flags faster, more reliable, and way more automated. That means better (and more!) SDKs, more powerful local evaluation, supporting real-time use cases, and using AI to handle the tedious stuff. We're also talking to a bunch of users to figure out what to build next, fixing the foundations so nothing breaks, and shipping features that make flags easier to wrangle when you have thousands of them.

Awesome documentation Dylan Martin

Our docs should be as good as the experiments team's. We're partnering with the content team to refresh everything, writing real-world walkthroughs, and making it easier to jump from the app to the right docs.

Make local evaluation the default server-side evaluation strategy Dylan Martin Phil Haack

Local eval means faster, cheaper, and more reliable flags. We want to make it the default for server-side SDKs by:

  • Finishing HyperCache integration to decouple /local_evaluation from Postgres
  • Solving the properties problem that's been blocking adoption (it's not very ergonomic to bring your own properties to everything, we'd love to improve this experience)
  • Rewriting the endpoint in Rust for better performance
  • Adding ETag support for efficient caching
  • Writing better docs and guides

Ship a Java SDK Dustin Byrne

Java developers need an official SDK. We're shipping one and iterating based on feedback.

Improve SDK standardization Dustin Byrne

Inconsistent SDKs lead to bugs. We're burning down the SDK standardization meta-issue to create a consistent experience across the stack.

Mature the Cohorts UI/UX Gustavo Henrique Strassburger

Cohorts has been neglected. We're clearing the backlog and fixing UI bugs so cohorts is actually pleasant to use by end of Q4.

Real-time feature flags Gustavo Henrique Strassburger

Some use cases need instant flag updates without refreshes or restarts. We're adding WebSocket/SSE-based real-time updates to key SDKs.

Finish behavioral cohort targeting Dylan Martin

We started building a system to track behavioral cohort membership in a fast data store. We're finishing it so you can target flags based on behavioral cohorts.

Flag staleness cleanup system Phil Haack

Stale flags are tech debt. We're building tools to:

  • Detect and surface stale flags in the UI
  • Make cleanup easy with in-app tools
  • Generate prompts for Cursor/Claude Code to remove flags from your codebase
  • (Stretch) Automated actions like creating cleanup PRs

Natural language flag creation Phil Haack

Building flags with AI. You describe what you want in plain English, Max builds the flag.

Enhanced flag evaluation debugging capabilities Dylan Martin

Better visibility into why flags evaluate the way they do. We're adding evaluation properties to $feature_flag_called events and showing flag evaluation history for each person.

Platform improvements Dylan Martin

Fixing the foundations:

  • Finishing the persons database split (shared with ingestion team)
  • Decoupling /flags from the writer database so flags stay up even when the database is down
  • Rewriting /evaluation_reasons in Rust
  • Deprecating the legacy /decide endpoint

Customer interviews around UI/UX improvements (Shared goal across the team)

We're doing 10+ user interviews about flags UI and cohorts to figure out what to build next. This feeds directly into our roadmap for both products.

We do 2-3 short interviews, then pay you to do some real-life (or close to real-life) work.

  • 1
    Application (You are here)
    Our talent team will review your application

    We're looking to see how your skills and experience align with our needs.

  • 2
    Culture interview
    30-min video call

    Our goal is to explore your motivations to join our team, learn why you’d be a great fit, and answer questions about us.

  • 3
    Technical interview
    45 minutes, varies by role

    You'll meet the hiring team who will evaluate skills needed to be successful in your role. No live coding.

  • 4
    Founder interview
    30 minutes

    You have reached the final boss. It's time to chat with James or Tim.

  • 5
    PostHog SuperDay
    Paid day of work

    You’ll meet a few more members of the team and work on an independent project. It's challenging, but most people say it's fun, and we'll pay you $1,000 for your efforts!

  • 6
    Offer
    Pop the champagne (after you sign)

    If everyone is happy, we’ll make you an offer to join us - YAY!

(Now for the fun part...)

Just fill out this painless form and we'll get back to you within a few days. Thanks in advance!

We'll need this for the SuperDay

Seriously, just write a couple of sentences about why you love us and you'll be doing better than 90% of applications.

Questions about this page? or post a community question.