Internal — Engineering

Rival 2.0 — Engineering Culture & Practices

A software factory, not a software sweatshop.

Context

What Rival 2.0 Is

Three models for delivering research. One of them scales.

The Agency

  • 6 weeks to a deck
  • Pays for headcount
  • Doesn't scale

SaaS

  • Self-serve
  • No outcomes

Service as Software

  • Research outcomes
  • Software + AI + Engineers

The software is the service.

How We Work

Operating Model

Remote-First

Everything that matters is written down.

Generalist Engineers

Any engineer, any layer, any track.

The PM

Owns features start to finish. In the room from day one.

Bottlenecks

Code is not the constraint. Decisions and deploys are.

Staffing

Team Phases

How the team grows as the product matures.

Phase 1

Months 1–3 · Building the factory
HoE
SSE
SSE
PM
UX
HoE (star)
SSE
PM · UX
→ Signal: platform fragile with 1 engineer

Phase 2

First customers · Informal FDE
HoE
SSE
SSE
PM
UX
SSE (FDE mode)
SSE (platform)
→ Signal: demand grows

Phase 3

Demand grows · Full rotation begins
HoE
SSE
SSE
SSE
PM
UX
FDE
Platform ×2
People

Roles

Small team. Clear ownership. No coordination overhead.

Head of Engineering

HoE

Owns
  • Architecture decisions
  • Engineering culture & hiring bar
  • Review pipeline design
Not in scope
  • Writing all code
  • Approving every PR
Splits when architecture needs full-time ownership. Preferred path: promote a founding engineer.
Senior Software Engineer
Platform Mode
Owns
  • Core platform development
  • AI pipeline, infra, tests
  • Module boundaries
Not in scope
  • Staying in one layer
FDE Mode
Owns
  • Customer-facing delivery
  • Embeds with customers
  • Surfaces product friction
Not in scope
  • Waiting for PM to find problems
Product Manager

PM

Owns
  • Features start to finish
  • Briefs, priorities, decisions
  • In the room with engineers
Not in scope
  • Gatekeeper or coordinator
  • Ticket triage
UX/UI Designer · 0.5

Designer

Owns
  • Design system governance
  • Original UI & interaction work
Not in scope
  • Pixel-level review of every implementation
Structure

The Rotation

One engineer faces customers. The rest hold the platform. The seat rotates.

2 Engineers

Early stage

A
B
B informally shifts toward customers

Both on platform. One shifts informally when customers arrive.

3 Engineers

24-week cycle

A
B
C

One FDE. Two always on platform. A→B→C→A cycle.

4 Engineers

Asymmetric — staggered

A
C
B
D
2 FDE + 2 Platform, staggered handoffs

Asymmetric. Always one experienced engineer per track.

8-week rotations. 2-week written handoff. Document committed to the repo.
Information Flow

FDE / PM Signal Flow

Customer
Signal source
→
FDE
Hears signal
→
PM
Owns decision
→
Brief
Written spec
→
Engineers
Build it
→
Platform
Ships it
↩ Platform knowledge flows back to FDE
FDE owns the signal. PM owns the decision. Both are in the room.
Quality

The Review Pipeline

Eight phases. Most of them automated. None of them optional.

Phase 0
Secrets
Hard Gate
Blocks push
Phase 1
Static Analysis
Hard Gate
Phase 2
Arch Drift
Hard Gate
Phase 3
Code Review
Soft Gate*
Phase 4
Feature Gaps
Async Report
Phase 5
Security
Async Report
Phase 6
Performance
Async Report
Phase 7
Observability
Async Report

Phases 3–7 are all Claude. Different prompts, same diff.

* Soft gate: must respond to each finding before merge.

Process

Specs as Decision Records

Writing before building. One spec. One PR. Every time.

Step 1

Brief

PM

Problem + who + why now + success criteria

→
Step 2

Design Spec

Engineer PM

How it works + what it doesn't do + rejected alternatives

→
Step 3

Architecture Note

HoE

Primitives + patterns + boundaries

One spec. One PR. Always.
Quality

Testing Pyramid

Each layer catches what the one below misses.

Unit Tests

forge(), verifyProgram(), schema validators. No LLM mocks.

Contract Tests

LLM call boundaries. Shape in, shape out.

E2E Playwright

Auto-generated from survey.js + flow_json at publish time.

Synthetic Respondents

Run on every flow change. Catches silent regressions.

More tests, lower cost Higher confidence, fewer
Targets

Velocity Targets

4h
PR cycle time
From open to merge
1wk
Spec to production
For a single feature
Daily
Deploy frequency
Every working day
<5%
Change failure rate
Deploys that cause incidents
<1h
Mean time to restore
When things go wrong
Standards

Non-Negotiables

Six rules. All of them enforced automatically where possible.

01

No code without a spec.

If it isn't written down first, it doesn't get built.

02

No agent merges its own code.

AI writes, humans approve. Every time, no exceptions.

03

No secrets in the repo.

Phase 0 blocks the push. The pipeline never reaches review.

04

No module boundary violations.

Architecture drift is a hard gate, not a code comment.

05

No PII in structured logs.

Logs are observable by default. PII is never written there.

06

No shipping without a trace ID.

Every request, every flow, every error has a trace ID from entry to exit.

Roadmap

Implementation Timeline

Month 1

Factory Floor

  1. Establish repo structure and module boundaries
  2. Configure pre-commit secret scanning
  3. Set up static analysis (ESLint + TypeScript strict)
  4. Write architecture decision records for all major patterns
  5. Build first unit test suite with full schema coverage
  6. Define spec template and brief format
  7. Document deploy pipeline end to end
  8. Set trace ID standard across all services
  9. Onboard engineers to review pipeline and rotation model
Month 2

Review Pipeline

  1. Integrate Claude review prompts into CI (Phases 3–7)
  2. Ship contract test layer for all LLM boundaries
  3. Auto-generate E2E Playwright tests from publish flow
  4. Run first synthetic respondent suite on all active flows
  5. Retrospect on pipeline friction and calibrate soft gates
Month 3+

Ship Product

"Every line of code is born into a system that catches problems automatically."