R/reports/fullstack

Must have

• TypeScript, JavaScript, Python, React
• Node.js, Next.js, Postgres, SQL, REST APIs, GraphQL
• AWS, Kubernetes, Docker
• HTML, CSS, Git/CI-CD

Nice to have

• Go, Ruby on Rails, Java/Kotlin, Rust, Scala, C++, C#, Haskell, Lua/Luau, Swift/Objective-C
• Django, Flask, SQLAlchemy, FastAPI, Express, Apollo GraphQL, Redux, MobX, Tailwind CSS, Angular, Vue, Svelte, React Native
• MySQL, MongoDB, Redis, ClickHouse, Elasticsearch, Cassandra, vector databases
• Kafka, Temporal, Celery, Prometheus, Terraform, Helm, GCP, Azure
• Eppo, Statsig, Optimizely
• Cloudflare Workers, Vercel Edge Functions
• OpenTelemetry, MCP, Cursor, Claude, GitHub Copilot

Full-stack product engineering

• End-to-end ownership - take a feature from spec/design through API + data model, frontend, launch, and iteration; scope ambiguous problems and cut scope under deadline.
• Service and schema design - service boundaries, relational schema design (Postgres), data models that survive long-lived decisions (permissions, collaborative editing), REST/GraphQL API ergonomics.
• Scaling and reliability - microservices/SOA, high-throughput services (20M+ QPS at the high end), caching, performance budgets, observability (logs/metrics/traces/dashboards), on-call and production debugging.
• Architecture evolution - monolith-to-modular migration, BFF layer, shared component/design systems, reducing duplication without stalling feature velocity.

AI-native application features

• Agentic systems - planners/executors, tool calling and tool schemas, agent orchestration engines, long-running jobs, human-in-the-loop review flows, agent observability and conversational audit trails.
• Retrieval and document pipelines - RAG (client- and server-side), document ingestion at scale, structured/deterministic outputs, semantic models, serializing DB context for accurate generation.
• Evals and quality loops - evaluation frameworks, A/B-tested prompt/clarifying-question flows, escalation logic, production quality metrics feeding model/engineering decisions.
• LLM product plumbing - streaming results UX, classifiers for high-intent segmentation, personalization/ranking surfaces wired to adoption and revenue.

Frontend craft and performance

• High-performance UI - Web Vitals optimization across browser→API→data, profiling, caching, 60FPS data-heavy interfaces, resilient state management (Redux/Flux/MobX), error handling.
• Data-dense interfaces - dashboards, query/debugging tools, novel visualizations for structured/unstructured data, real-time/streaming state, large-dataset rendering.
• Cross-platform delivery - web, mobile (React Native/iOS/Android), desktop, PWA/extensions; rendering models and lifecycles across frameworks (SSR, edge runtimes, server components).
• Accessibility and design-system work - reusable components, internal design systems, security UX for regulated/enterprise environments.

Growth and monetization engineering

• Funnel engineering - acquisition, activation, onboarding, retention, conversion, paid-upgrade surfaces; hill-climbing activation rate, paid conversion, habit formation.
• Experimentation - hypothesis→instrumentation→implementation→analysis→rollout; trustworthy experiment readouts; shipping many experiments in parallel; SQL self-serve funnel analysis.
• Monetization mechanics - usage-based billing, paywalls, subscription/freemium systems, usage metering, smart upgrade triggers, contextual CTAs, pricing experiments.
• SEO/GEO and edge web - edge-served dynamic SEO content, web discoverability, LLM-era search optimization.

Data-intensive and observability systems

• High-cardinality telemetry - ingest/store/query sessions, events, traces, logs; columnar/analytical stores; indexing, query optimization, recall/latency and cost trade-offs.
• Pipelines and governance - ETL, analytical data models, serving layers, schema evolution, data quality/tagging standards, real-time systems (WebSockets, Pub/Sub, streaming).

The 20% that covers 80%
The dominant, near-universal stack is small. Master it deeply before anything else and you clear the bar for most postings.

• TypeScript + React on the frontend
• Python (and/or Node.js) + Postgres on the backend
• REST/GraphQL APIs, plus AWS + Kubernetes for deployment

Table-stakes vs. genuine differentiators
The core stack is assumed, not impressive. What separates senior/staff candidates is shipping AI-native features and owning experimentation.

• Differentiators: agent orchestration + tool-calling, RAG/retrieval, evals, A/B experimentation with clean instrumentation
• Table-stakes: CRUD APIs, React UIs, relational schema design, CI/CD

Smallest high-leverage cluster - fastest path to qualified
One AI-native full-stack project on the canonical stack unlocks the most roles: a TypeScript/React + Python/Postgres app that calls an LLM, does retrieval, orchestrates a tool-calling agent, and measures quality with evals or an A/B test.

Rising vs. fading
Effort is best spent where demand is visibly growing across these postings.

• Rising: agentic orchestration, evals/observability for LLMs (OpenTelemetry, tracing), usage-based monetization, edge runtimes, AI-assisted development fluency (Cursor/Copilot/Claude)
• Steady but commoditized: generic SPA work, plain CRUD backends

Interchangeable vs. non-negotiable
Learn one from each interchangeable group; do not skip the non-negotiables.

• Non-negotiable: TypeScript, React, Python, Postgres, AWS, Kubernetes
• Interchangeable (pick one): Go/Java/Kotlin/Ruby for a second backend; Eppo/Statsig/Optimizely for experimentation; MongoDB/MySQL as a second datastore; Cloudflare Workers/Vercel Edge for edge

Gaps that create leverage (required but rarely held)

• LLM evals and production quality measurement (asked for repeatedly, genuinely scarce)
• High-cardinality data + columnar storage (ClickHouse-class) with query optimization
• Permissions/authorization and security UX at enterprise scale

Transfers across domains - one investment, many roles

• Experimentation + funnel instrumentation transfers across every Growth role (Perplexity, Cursor, LangChain, Discord, Semgrep, Postman, Roblox)
• Agentic/RAG plumbing transfers across Harvey, Cohere, Decagon, Scale, Glean, Sigma, Replit, Notion
• Data-heavy UI + API design transfers across observability/analytics (Grafana, ClickHouse, LangChain, Sigma, Scale)

Company-stage signals reward differently

• Unicorns/growth AI (Harvey, Cohere, Replit, fal, Decagon, Scale): 0→1, agentic features, customer-facing ambiguity, high ownership
• FAANG-plus/mature (Roblox): scale (QPS), A/B rigor, cross-platform, OOP depth (C#/Java/C++)
• Fintech/regulated (Rippling, Brex, Plaid, Mercury, Gusto): compliance, money movement, reliability, product polish over novelty

Unique to this niche
Almost every role is full-stack + product-minded + AI-adjacent at once - pure-backend or pure-frontend specialists are rare here. The combination of UI craft, backend ownership, and LLM/agent literacy is the defining trait.

Lead with end-to-end ownership of a shipped, measurable AI feature
The signal that drives most decisions is "owned X from spec to launch and moved a metric." Put a number on it.

• Strong: "Shipped agentic onboarding flow (Next.js/React + Python); +18% activation via 12 A/B tests"
• Weak: "Worked on onboarding features"

Go one level deeper than peers on agents and evals
A resume line that names the hard mechanism reads as depth, not buzzwords.

• "Built tool-calling agent with retry/guardrail taxonomy and eval harness (recall@k, human-review scoring) gating model changes in prod"
• "Cut hallucinated answers 40% by serializing DB context into deterministic semantic models"

Projects eng managers are hoping to find

• Agent observability tool - surfaces agent performance, usage, and conversational audit trails; line: "Built governance dashboard for AI agents serving 50+ enterprise customers."
• RAG/document pipeline at scale - ingestion growing 10x/6mo across many jurisdictions; line: "Designed ETL + retrieval pipeline ingesting 10M+ docs with structured-output extraction."
• Growth experimentation platform - line: "Built in-house experimentation + usage-metering system powering self-serve monetization."
• High-cardinality telemetry UI - line: "Shipped query layer + dashboards over petabyte-scale event data at sub-second latency."

The combo that's an immediate yes
Canonical stack + AI-native feature + measurable business/quality outcome + scale number. That single line answers "can they build it," "do they get AI," and "did it matter."

What reads junior

• Task lists with no ownership or metric: "Implemented React components and fixed bugs"
• Tutorials-as-projects: "Built a to-do app with React and Node"

What reads senior/staff

• Same work, leveled up: "Set frontend architecture and design system adopted by 8 product teams; defined performance budgets cutting p75 load 35%"
• "Led 0→1 product through 3-week sprints; defined service boundaries and drove cross-team adoption"

Red flags that make recruiters pass

• Stack-name soup with no shipped artifact: "Familiar with React, Python, AWS, Kubernetes, LLMs, RAG, agents"
• AI as decoration: "Used ChatGPT in projects" with no system, eval, or outcome
• Staff title, IC-junior scope: senior/staff resumes must show influence without authority, mentorship, and architecture decisions - not just feature delivery

Worth flagging

• AI-assisted development fluency (Cursor/Copilot/Claude) is now an explicit expectation at several companies - showing it is a small, easy edge.
• Public proof matters here: open-source contributions, a GitHub, or a portfolio are repeatedly called out as pluses (Cohere, Sentry, Anthropic, Mercor) - and several postings screen hard against AI-generated spam applications, so authenticity and specificity in your write-ups count.