Staff Software Engineer, Product (Campinas)

Staff Software Engineer, Product — AI-Accelerated Product Engineering (Campinas)

Own outcomes. Build end-to-end initiatives that move real marketplace metrics—and do it with AI coding agents that help a small, senior team ship faster without lowering the bar. If you’re the kind of engineer who can frame the problem, design the approach, direct agent workflows, and stand behind production quality, this is your place.

This is a remote role for candidates located in Campinas, Brazil.

About LawnStarter

LawnStarter is the nation’s leading on-demand marketplace for lawn care and outdoor services, with $100M+ in annual bookings. We’re expanding beyond lawn care to become the one-stop shop for all home services—running three brands on a single shared platform:

• LawnStarter
• Lawn Love
• Home Gnome

We’re building products customers love and tools pros rely on—at scale.

About Engineering at LawnStarter

We build in small, focused initiative teams—a Product Engineer works alongside a PM and designer, supported by an Engineering Manager focused on growth. You’ll also collaborate closely with peers across adjacent initiatives in a shared codebase.

Teams own whether the work moves the metric.

AI coding agents are a force multiplier for us: they give small, senior teams leverage to ship more quickly and with high quality. We hire engineers who are deeply wired for ownership and energized by shipping to a live marketplace with customers and pros on both sides.

About The Role

You’re the engineering anchor of an initiative. That means you’re not just implementing—you’re shaping the arc from problem framing to post-launch learning.

You’ll work with a tight team (PM + designer) and engineering peers across initiatives, owning the full lifecycle:

• Shape the problem with your PM and designer
• Decide the technical approach (architecture, data model, integrations, rollout)
• Direct AI agents to implement the majority of the code safely and correctly
• Ship to production with strong observability and rollback plans
• Own the outcome with your team via post-launch metric review

You’re measured by impact, not lines of code merged. When agents can ship something safely, your job is to ensure it’s done right and that the metric moves. When the work requires careful, hand-written code in sensitive areas, you write it yourself.

What You’ll Own

• The technical approach
  • Architecture and system boundaries
  • Data model and integration choices
  • Rollout plan
  • Observability and regression detection
  • Rollback strategy
• Implementation quality
  • Prompts, guardrails, and agent workflows
  • Evals that catch issues before merge
  • Tests that exercise edge cases
  • A review loop that keeps production correctness high
• Cross-functional partnership
  • Daily working contact with your PM (scope, tradeoffs)
  • Daily partnership with your designer (UX decisions, in-tool prototyping)
  • Regular collaboration with engineering peers across the shared codebase
  • Weekly check-ins with your Engineering Manager
• The initiative outcome
  • The specific metric your initiative was set up to move
  • Presenting results 2–4 weeks post-launch with your PM
  • Sharing the “did it work?” answer—not just the release notes
• A high bar for what ships
  • Production correctness
  • Security
  • Performance
  • Observability
  • Customer + pro experience

What Makes This Role Exciting

• End-to-end ownership — from problem framing through production to post-launch metric review.
• True product partnership — sit with PM + design and bring engineering judgment to product calls (and product sense to engineering decisions).
• Autonomy with smart checkpoints — you’ll make most technical calls, with architect review for significant architectural decisions and fast input from peers.
• Staff-level trust — you’ll be expected to ship the hard thing and stand behind the outcome.
• AI as leverage — agents accelerate delivery, while you ensure safety, quality, and real-world correctness.

Problems You’ll Solve

• Leading AI agents at a staff-level quality bar
  • Most code will be authored by AI agents—your job is making it ship “as if a senior engineer wrote it.”
  • Build workflows that include:
    • Prompts that encode our conventions
    • Evals that detect failures early
    • Tests that cover edge cases
    • Observability that catches regressions before customers do
  • Create a system where a small team can ship far more than its size suggests.
• Owning decisions with high autonomy
  • Move quickly with real latitude to make and document technical calls.
  • Use architect review for big architectural decisions and peer pressure-testing for confidence.
  • Keep speed high, alignment tight, and accountability clear to the outcome.
• Shipping outcomes, not just features
  • Each initiative is tied to a measurable metric (e.g., conversion rate, retention curve, pro-funnel KPI, unit economics shift).
  • Scope work to actually move the metric.
  • Exercise discipline: follow up 2–4 weeks after launch and evaluate what happened.

What Success Looks Like (Year 1)

• Initiative outcomes hit
  • Ship 3–4 initiatives end-to-end
  • At least two clearly move their metric (validated by post-launch review)
• Agent workflow that travels
  • Your prompts, evals, and review loop become reusable patterns for other initiatives
• Faster cycle time
  • Meaningfully shorter time from problem framing to first production rollout
• Quality holds
  • No customer- or pro-facing regressions traceable to agent-authored code that slipped through review
• Visible leverage
  • Peers use your artifacts—runbooks, evals, agent workflows, and post-launch write-ups

What We’re Looking For

• AI-native
  • You ship daily with tools like Claude Code, Cursor, Codex, or equivalent
  • You have strong opinions about prompts, evals, agent loops, and review workflows
  • You know when to let the agent run and when to write yourself
• Operating at a lead level
  • Even if your title isn’t “Staff” today, you’re the person making the call, shipping the hard thing, and owning whether it worked
• Outcome-driven mindset
  • You measure your week by “did the metric move?” and “did the experience improve?”
  • You review post-launch dashboards and take ownership of the answer
• Strong horizontal partner
  • You collaborate effectively with PMs and designers
  • You bring engineering judgment to product calls—and product judgment to engineering calls
  • You hold your own with engineering peers in a shared codebase
• Decisive and documented
  • You make architecture, data-model, and rollout decisions quickly
  • You document them, request fast input, and adjust when the data proves you wrong
• A force multiplier
  • Your impact compounds beyond your initiative through reusable artifacts:
    • Agent workflows
    • Evals
    • Runbooks
    • Post-launch reviews
• Customer- and pro-minded
  • You understand this is a real marketplace with real people on both sides
  • You care about outcomes for both customers and pros

Good to Know

• Individual-contributor role with growth
  • People management is handled by your Engineering Manager
  • If you want to move into management later, the path is open
• Product engineering, end-to-end
  • You ship work that moves metrics
  • Platform and architecture work happens inside the initiative when it’s needed to achieve the outcome
• Hands-on with a high quality bar
  • Agents handle much of the implementation
  • You bring judgment, safety, and accountability
  • The bar stays high—always
• Shipping to a live marketplace
  • With $100M+ in bookings, customers and pros use what you ship within the same week

Tech You’ll Touch

• AI agents
  • Claude Code, Cursor, Codex
  • Internal agent stack
  • MCP servers
  • Evals tooling
• Backend
  • PHP / Laravel
• Frontend
  • TypeScript / React / React Native
  • Customer & pro apps (web + mobile)
• Data
  • Redshift, dbt
  • Segment
  • Airflow
• Infrastructure & observability
  • AWS
  • Datadog
  • Sentry
  • GitHub Actions
• Documentation &