Backend Engineer

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.

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.

Salary

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)

Country

Region

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.

Benefits

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

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

Your team's mission and objectives

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

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

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

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

Improve SDK standardization

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

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

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

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

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

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

Enhanced flag evaluation debugging capabilities

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

Platform improvements

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.

Interview process

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!

Apply

(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!

Name*

Email*

GitHub*

We'll need this for the SuperDay

Cover letter

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

Resume/CV*

Upload fileor drag and drop here

LinkedIn

Portfolio/Personal website

How did you hear about us?

Where are you located?*

Do you require sponsorship to work in your desired location?*

Submit

Questions about this page? Ask Max AI or post a community question.