Pearl Talent - Code-based Automation Engineer

We're hiring an Automation Engineer for Pearl, which finds exceptional talent from around the world, trains them to be AI-native, and places them into operational roles at startups as managed contractors: from client-facing roles to software engineers to executive assistants. We're 3x founders who've bootstrapped our company to a couple million in ARR and are adding six to seven figures in net new annualized revenue each month. Our clients span venture-backed tech and healthcare, including fast-growing startups and phenomenal US-based businesses that have raised over $3B in funding from Sequoia, a16z, Founders Fund, Y Combinator, and other top VC firms.

Today we're roughly 50 people managing a few hundred talents, growing fast and into new verticals. We started Pearl because we believe that even though opportunity isn't created equal in the world, ambitious talent is. And our goal is to scale Pearl to $100M in ARR bootstrapped by placing 2777 operators into top startups in the next 3 years.

Location: Remote-first, with meaningful overlap with US business hours

Purpose of Your Role

Pearl runs on automation. Candidate profiling, CRM hygiene, client reporting, talent operations — a meaningful share of the business moves through n8n, Zapier, and a long tail of low-code glue. That got us here, and it will not get us to $100M.

Your job is to move Pearl's business-critical workflows off no-code and onto a code-first foundation: version-controlled services, durable orchestration, real observability, and recovery paths that don't depend on someone noticing a workflow went red. You'll be handed automations that work until they don't, and you'll return infrastructure that can be tested, monitored, and safely operated by an engineering team.

This is not a "wire up another Zap" role. You're rebuilding the operating substrate of the company.

What You'll Own

• Migration from No-Code to Code

• Own the transition of business-critical automations off n8n, Zapier, and similar platforms into maintainable software services

• Reverse-engineer triggers, steps, dependencies, business rules, retries, and the edge cases nobody documented

• Sequence migrations by business criticality, reliability risk, and maintenance burden — not by what's easiest to lift

• Validate migrated behavior against production before anything legacy gets deprecated, with a clear rollback path every time

• Durable Orchestration and Integrations

• Build long-running, failure-resistant workflows in Temporal.io or a comparable orchestration framework

• Design for the real world: API outages, worker restarts, rate limits, partial failures, and processes that run for days

• Implement retries, timeouts, idempotency, checkpoints, and state management; keep orchestration separate from business logic

• Build and maintain integrations across our CRM/recruiting stack, Supabase/PostgreSQL, Google Sheets, Slack, and internal APIs — as reusable connectors, not one-offs

• Reliability, Observability, and Data Integrity

• Make failures visible, diagnosable, and recoverable instead of silent

• Ship structured logging, monitoring, alerting, and execution visibility; build clear mechanisms to replay and recover stuck jobs

• Prevent duplicate processing through idempotent operations and explicit execution boundaries

• Build reconciliation and audit trails where they matter, and respect source-of-truth and ownership boundaries across production systems

• Engineering Standards

• Write clean, documented, well-tested Python and/or TypeScript, shipped through Git, code review, automated testing, and CI/CD

• Document architecture, dependencies, assumptions, and recovery procedures so the next person isn't reverse-engineering you

• Help define the reliability standards the rest of our automation infrastructure gets held to

Example Projects

•
n8n to Temporal migration: rebuild a multi-step operational workflow as a durable Temporal workflow with retries, recovery, and full execution visibility

•
System synchronization: replace a fragile low-code sync with a code service that keeps operational systems aligned safely

•
Reconciliation jobs: detect missing, duplicated, or inconsistent records across systems and create controlled recovery paths

•
Reusable integrations: build the common connectors and patterns so new automations stop reinventing API logic every time

What Success Looks Like

Within your first year, Pearl's critical business processes run on code, not on a canvas. The workflows that used to break quietly now fail loudly, retry themselves, and can be replayed from a checkpoint. Ops and TA stop filing "the automation didn't fire" tickets because the automation fires - and when it doesn't, someone knows within minutes and has a documented path to recovery. New integrations take days instead of weeks because the connectors already exist. The company can add headcount and volume without anyone asking whether the glue will hold.

Requirements

What We're Looking For

• You might look like one of the following:

• A backend engineer who's owned integrations, internal tooling, or automation infrastructure at a startup

• A platform or infrastructure engineer who's built durable workflow systems and lived with the on-call consequences

• An engineer who inherited a sprawling low-code stack and successfully migrated it into production software

• An automation-heavy full-stack engineer who's tired of prototypes and wants to build the real thing

•
Strong backend fundamentals, in Python and/or TypeScript. You've built services, not just scripts.

•
Deep comfort with APIs and async work. REST, webhooks, auth, pagination, rate limits, queues, and asynchronous jobs are familiar territory. Strong SQL and PostgreSQL fundamentals.

•
You understand failure. Retries, idempotency, distributed systems, and recovery patterns are how you think about design, not something you bolt on after the first incident.

•
You can reverse-engineer. You can look at an undocumented workflow someone built 14 months ago and translate the business logic into reliable software without breaking what depends on it.

•
Production discipline. Git, testing, CI/CD, logging, monitoring, and actual production operations experience.

•
Systems over heroics. You'd rather build the thing that prevents the fire than be great at fighting it.

•
Nice to have: Temporal.io or another orchestration framework; n8n, Zapier, or Make (especially paired with migrating off them); Supabase and event-driven architectures; Docker and cloud deployment; recruiting/CRM platform integrations; AI/LLM workflow or agent infrastructure.

Benefits

•
Build and Grow Quickly - We’re scaling fast, and we trust that you’ll know best on the ground what needs to be done. You’ll have the opportunity to step into leadership early and own decisions that shape how our company grows.

•
Fully Remote. Forever. - We’ve built Pearl with a multicultural DNA and teammates across 23 countries. We trust that the best work isn’t done behind a cubicle

•
Unlimited PTO - We trust that you’ll get your work done, and we want to create space for you to take time away with the people you care about.

•
Global Retreats - We create space for our teammates to get to know each other as people, rather than just to-do lists. We’ve shared meals, laughs, and sunrises across the world in places like Cancun, El Nido, Boracay, and Siargao**.**

•
Ambitious and Kind Team - We build with the most competent people we know, and we maintain a low-ego, no-assholes policy. We’re looking for people who are sharp, kind, and open to being vulnerable when it matters.

Originally posted on Himalayas