Senior Software Engineer, Infrastructure & Release

Responsibilities

You will lead infrastructure at Feanix, owning the foundation for the engineering team to ensure stability, efficiency, and speed. This includes managing the end-to-end delivery ecosystem, from CI/CD and release tooling to observability and infrastructure cost management.

Requirements

The role requires strong experience with OpenTofu or Terraform, deep AWS knowledge, and proficiency in Python. Candidates should have a background in release engineering, operational judgment, and a proactive approach to integrating coding agents into infrastructure workflows.

Skills

• OpenTofu
• Terraform
• AWS
• ECS
• Fargate
• Python
• CI/CD
• Release engineering
• Observability
• Infrastructure as code
• GitHub Actions
• OIDC
• Security fundamentals
• Fleet management
• Regression testing
• System architecture

Benefits

• Medical coverage
• Dental coverage
• Vision coverage
• 401k
• Pet insurance
• Flexible paid time off
• Paid parental leave
• Equity options

About this role

About Feanix Bio
Feanix is rebuilding animal breeding from the genome up.
We’re a YC-backed startup using whole-genome sequencing and custom ML models to help dairy farmers make better breeding and herd management decisions. Our technology is genuinely novel: we can sequence a full genome from a single hair at a fraction of traditional industry costs, our models achieve ~90% prediction accuracy on traits where existing approaches sit closer to ~30%, and we’re pioneering farm-specific genomic predictions that turn genetics into practical, actionable decisions.
That technology is translating into real adoption. In a short time, we’ve grown to serve roughly 1% of the U.S. dairy industry, with many customers in the pipeline. We started with dairy because our founders grew up on dairy farms and understand firsthand the problems we’re solving. But genetics is foundational to every agricultural industry, and dairy is only the beginning.
We’re building Feanix with a small, high-caliber team where people have meaningful ownership and work end to end. There are no unnecessary layers and very little room for busywork — just difficult problems at the intersection of biology, data, and software that haven’t been solved before.
If you’re exceptional at what you do and want your work to have a measurable impact on an entire industry, we’d love to build it with you.
About The Role
Feanix’s main product Autopilot is a farm decision system. We ingest farm data, configure our models around each operation's economics and goals, and generate farm-specific decisions for every animal in the herd — which to breed, which to cull, which to sell. Autopilot produces those decisions overnight and delivers them into the herd-management software the farm already runs.
Today we work with 30 of the roughly 150 largest dairies in the country, ~250,000+ cows. Over the next 5 months we need to grow to 50 farms, and within 12 months to half of that market, while launching new offerings beyond what we ship today.Most of the software behind that system currently is supported by a small team of engineers. This role exists to increase the stability, efficiency and speed of that team and system.
You would lead infrastructure at Feanix — you'd own the foundation the other engineers build on and your success would be measured in their throughput: how fast they learn whether a change is safe, and how fast they find out something didn't run. We've added the basics — observability, testing and release tooling as we've grown. What's missing is someone owning it end to end.
The job is the whole delivery ecosystem — everything between an engineer's commit and decisions landing on a farm: the environments a change is proven in, the gates it passes, how it rolls out, and how we know it arrived. Today a change can't be exercised end to end against realistic farm data before it reaches production, which shapes how cautiously (or indeed how riskily) everyone works. The reliability half isn't the usual one, we don't run a low-latency service, we run pipelines overnight, so what matters is whether a run started, finished, finished in time, and landed on the farm.
What You'll Own
Roughly half this role is CI, test and release engineering; a quarter is observability; a quarter is access control, cost, and consolidating our infrastructure as code. Work on a Windows fleet is a small slice.
Alerting and service-level objectives for the farm pipeline. What “decisions on the farm by time T” means per herd, instrumented and alerted. A run that never started, never finished, or finished late should reach a person before anyone on the farm notices.
The release path. Building out a path where staging runs on every commit and software engineers get quick feedback if the change was right.
Infrastructure as code, end to end. Agentic coding has not eliminated infrastructure as code, it has enhanced the speed it can be developed and changed.
Cost. There's a rough baseline today. You'd turn it into a real one, own the cost curve per herd, act on obvious waste, and help engineers estimate what something will cost before it ships rather than after.
Test infrastructure other engineers depend on, including for the third-party herd software and the machines that move files to and from farms. You'd make that boundary testable. You wouldn't own the automation itself.
How We Work
Python end to end, on AWS. A FastAPI service and Celery workers on ECS Fargate, PostgreSQL and S3 behind them, OpenTofu and GitHub Actions for everything that provisions and ships it. Bursty and GPU work runs on managed compute rather than a cluster we operate — the split is chosen per workload and it's deliberate.
Like everyone else, we're working out how humans and agents build software together. Our engineers direct agents against real work and build the harnesses that check that work. About half our recent commits are co-authored with agents. Quality comes from what happens around the code: specs, tests, verification. Nobody has this fully figured out, and that includes us.
Infrastructure as code is still the rule: changes are reviewed, versioned, and applied through CI, not typed into a console. So the question isn't whether agents write infrastructure, it's how agent-written infrastructure clears that bar. What does review mean when the author produced three hundred lines in a minute? Which checks have to be machine-enforced because a human reading a plan will miss the one line that matters? We care more that you verify agent output than that you use it. Bring yours and argue them out with us.
What You Bring
Strong OpenTofu or Terraform, and real AWS depth — ECS/Fargate, IAM, S3, networking
Test and release engineering: CI design, test environments with real databases, staged rollouts, and regression testing of pipeline outputs, not only unit tests
Operational judgment — alerting that pages on the right thing, service objectives that reflect what a customer actually experiences
Comfort...