Senior Data Infrastructure Engineer

We’re looking for a Senior Data Infrastructure Engineer to architect and operate high-performance

systems at scale using AI as a force multiplier.

This role has fundamentally shifted. You’re no longer constrained by typing speed or the breadth of APIs

you’ve memorized. With agentic coding tools, you can scaffold infrastructure, automation, and tooling at a

pace that was impossible a year ago. The bottleneck has moved: it’s no longer implementation, it’s

orchestration, decomposition, and direction.

You’ll design infrastructure in collaboration with AI, review and iterate on generated code, manage

multiple complex workstreams simultaneously, and ship infrastructure improvements at a velocity that, Before (Pre-Agentic): You spent 60% of your time writing code, database migrations, Bash scripts, and

monitoring configurations. The remaining 40% was architecture, decomposition, and problem-solving.

Now (Agentic Era): You spend 20% of your time writing that same code-except you’re orchestrating AI

to generate it, then reviewing and iterating. You spend the other 80% on what AI can’t do: deciding what

to build, why certain tradeoffs matter, and managing multiple infrastructure improvements in parallel.

What this means for this role:

• Handling Debian server management, disaster recovery, and capacity planning-but with AI generating

the majority of your automation scripts

• Designing PostgreSQL schemas and ClickHouse migrations-with AI scaffolding the implementation

and you validating the design

• Building monitoring and observability systems-10x faster than before

• Managing 8+ bare-metal servers and 1.2 PiB of data

• Working across multiple infrastructure subsystems simultaneously

What You’ll Work On

Infrastructure Architecture & Orchestration

• Design high-performance data processing systems, primarily in Rust

• Architect reliable systems for PostgreSQL, ClickHouse, Elasticsearch, and time-series databases at

scale

• Decompose complex infrastructure problems into tasks that AI can execute effectively

• Direct, review, and iterate on AI-generated infrastructure code

• Manage multiple infrastructure workstreams in parallel-something now feasible with agentic tools

Systems Administration & Operations

• Manage and operate 8+ bare-metal Debian servers with sophisticated automation

• Orchestrate infrastructure automation (Bash, configuration management, deployment tooling)

• Coordinate with remote hands for hardware installation, manage capacity, plan upgrades

• Build and maintain monitoring, observability, and alerting systems

• Troubleshoot the full stack: hardware, networking, OS, services, data

Performance Engineering Through Agentic Optimization

• Profile and benchmark systems; identify bottlenecks

• Iterate on optimization code-CPU, memory, query performance

• Reduce footprint while handling massive datasets by parallelizing optimization work

• Design systems optimized for bare-metal hardware without cloud provider constraints

Database Administration & Query Optimization

• Design PostgreSQL schemas and write optimized queries

• Maintain Elasticsearch indices; configure and optimize specialized databases

• Generate schema migrations, test them, iterate on tradeoffs

• Understand consistency, availability, and scalability tradeoffs deeply

Infrastructure Automation & Tooling

• Design AI-driven expert-level Bash orchestration

• Build automation that would previously have been too time-consuming to maintain

• Create monitoring, alerting, and observability infrastructure at scale

• Develop internal tools for the engineering team-deployment, debugging, performance analysis, You’ll make architectural decisions independently. You’ll also work closely with teammates on complex, Small, focused engineering team with deep systems expertise. You’ll collaborate directly with leadership

on infrastructure strategy and direction.

Technology Stack

• Rust (primary; written with AI pair-programming)

• PostgreSQL (relational data, OLTP)

• ClickHouse (analytical workloads)

• Elasticsearch (search and indexing)

• Bash/Python (operational automation, often AI-assisted)

• Debian Linux (server OS)

• Bare-metal infrastructure (8+ servers, 1.2 PiB storage)

AI Tools

• Claude Code (primary agentic tool for infrastructure work)

• Cursor or equivalent IDEs with agentic capabilities

• AI pair-programming is expected, not discouraged

Infrastructure Reality

• You’ll manage servers where hardware is physically installed via remote hands

• You’ll coordinate timing of upgrades and infrastructure changes

• You’ll monitor capacity, manage growth, and plan long-term

• You’ll troubleshoot the full stack: hardware, networking, OS, services, data

• Much of the tooling and automation will be AI-driven; you’ll review and iterate

Hardware Reality

Our infrastructure is physical. Real machines, real drives, real PCIe cards, real cabling. You won’t touch

them (remote hands will) but you’ll direct that work. Concretely:

• Speccing a server upgrade (drives, NICs, RAM, expansion cards) and writing the work order for

someone else to execute

• Diagnosing a failing drive or flaky NIC from SMART data, kernel logs, and ipmitool output

• Choosing a RAID layout, ZFS pool topology, or NVMe-over-fabric configuration based on workload, then

living with that decision for years

• Coordinating maintenance windows and tolerating “ticket filed * tech arrives Wednesday”

This requires a specific skill set: the ability to think in systems, decompose infrastructure problems

cleanly, direct AI-generated solutions, and review code critically. You need to be comfortable with “the AI

and I built this together”.

We primarily build in Rust and expect you to be comfortable with it or excited to become highly proficient.

We also use Bash, SQL, and Python extensively, often orchestrating all of them through AI-driven

workflows. If you’ve successfully used agentic coding tools (Claude Code, Cursor, GitHub Copilot X-level

capabilities), that’s a strong signal. If you’re skeptical of AI-driven development, this role probably isn’t for, You think in systems and decomposition, not syntax.

• You naturally break infrastructure problems into discrete tasks

• You can articulate clearly what an AI tool should do before asking it to do it

• You know the difference between a well-scoped prompt and a vague one

• You review generated code critically, not blindly

You’ve successfully used agentic coding tools.

• You have hands-on experience with Claude Code, Cursor, or equivalent agentic workflows

• You’ve shipped real infrastructure or features using AI-driven development

• You understand both the capabilities and limitations of current tools

• You’ve experienced the velocity increase and know what’s now possible

You’re comfortable with “AI-driven” as your default mode.

• You see AI tools as infrastructure accelerators, not threats

• You’re excited about managing multiple workstreams simultaneously

• You actively think about how to structure work so AI can execute it effectively

• You’re skeptical enough to review carefully, but not so skeptical that you dismiss the tooling

You still understand what you’re building deeply.

• The fact that AI generated the code doesn’t mean you don’t know how it works

• You can explain design decisions and tradeoffs, even for AI-generated systems

• You’re comfortable with bare-metal infrastructure complexity and operational realities

• You make architectural decisions based on system constraints, not on what’s easy to code

Core Technical Competencies

Rust Proficiency (or strong adjacent background)

• Production Rust experience, OR

• Strong systems programming background (C/C++, Go) with enthusiasm for Rust

• Understanding of performance-sensitive code patterns and low-level concepts

Systems & Infrastructure Knowledge

• Hands-on Linux/Debian server management (physical machines, not just cloud)

• Understanding of storage systems, RAID, networking, OS-level concepts

• Comfort with bare-metal infrastructure challenges

• Experience managing systems at scale (terabytes+, high throughput)

Database & Data Architecture

• You understand databases as architectures, not just as APIs., Track record optimizing systems for speed, memory efficiency, throughput

• Ability to profile, benchmark, and identify bottlenecks

• Designing systems where performance is a first-class concern

Infrastructure Automation

• Expert Bash scripting; command-line proficiency

• Ability to write automation that’s maintainable and reliable

• Configuration management or deployment tooling experience

Valuable Adjacent Backgrounds

• Infrastructure/SRE: You’ve built and operated production systems at scale

• Database specialization: Deep PostgreSQL, ClickHouse, or data warehouse expertise

• Performance engineering: You’ve profiled and optimized complex systems

• DevOps/platform engineering: You’ve built tools for other engineers

• Data lake / lakehouse experience: built or operated systems where object storage (S3, MinIO, Ceph)

is a first-class query target, not just a backup destination.

Qualities We Value

• Systems thinking - You understand interdependencies and tradeoffs

• Decomposition skills - You break problems into tasks AI can execute

• Code review discipline - You validate AI-generated code carefully

• Ownership - You take responsibility for systems you build and maintain

• Communication - You explain technical concepts clearly

• Pragmatism - You make decisions based on constraints and tradeoffs, not dogma

• Curiosity - You dig deep and understand what you’re building

Why You’ll Like Working Here

You’ll Work at a Different Velocity

Infrastructure improvements that took weeks now take days. You’ll manage multiple complex workstreams

simultaneously.

The Problems Are Real

You’re not optimizing for cloud benchmarks. You’re solving actual constraints: 1.2 PiB of data, bare-metal

hardware, performance-sensitive workloads, reliability at scale. The work is concrete and measurable., You’re skeptical of AI coding tools

• You’re uncomfortable with “the AI wrote most of it” architectures

• You need to understand every line of code before shipping it

• You’re primarily motivated by the craft of typing and writing code

• You prefer deep specialization in one system over managing multiple workstreams

If this sounds like you, it’s a great fit:

• You’ve used agentic tools and seen the velocity increase firsthand

• You’re more excited about architecture than syntax

• You’re comfortable directing AI, reviewing its work, and iterating

• You see infrastructure orchestration as a high-leverage problem

• You want to ship more complex work in less time

US$100K - 120K

We’re a venture capital firm investing in exceptional founders across 8 cities worldwide. We back

category creators like Mistral AI, Segment, Sonos and open-source leaders like NGINX, Bitwarden,

DBeaver.

Our engineering team is ambitious, international, and diverse. We’re building products that directly

support our investment thesis. We’re looking for engineers who want to work alongside talented

entrepreneurs and teammates-and who are excited about what’s possible when AI accelerates, OLTP vs OLAP fluency - you can articulate why PostgreSQL falls over on workloads ClickHouse

eats for breakfast, and vice versa. You don’t reach for a columnar store because it’s trendy; you

understand row vs columnar storage, vectorized execution, and what query shapes each is

optimized for.

• Storage hierarchy thinking - hot path in Postgres, warm analytics in ClickHouse, cold/archival in

object storage (S3-compatible) mounted into a data lake. You’ve made these tradeoffs in

production.

• Data lake patterns - Parquet/columnar formats, object storage as a query target (DuckDB,

ClickHouse over S3), and the operational realities of cheap storage + on-demand compute.

• Schema & query design under constraints - partitioning, sharding, materialized views,

denormalization for analytics. Decisions based on access patterns, not dogma.

• Operational depth in Postgres - replication, vacuum behavior, index bloat, query planner quirks,

lock contention. Schema design is table stakes; operating Postgres at scale is the differentiator.