At Zapier, we build and use automation every day to make work more efficient, creative, and human. So if you’re using AI tools while applying here - that’s great! We just ask that you use them responsibly and transparently.
Check out our guidance on How to Collaborate with AI During Zapier’s Hiring Process, including how to use AI tools like ChatGPT, Claude, Gemini, or others during our hiring process - and when not to.
Job Posted: April 13th, 2026
Location: India | Timezone = Overlap with US East Coast hours required 3–4 days/week during ramp-up
Zapier is seeking a Backend Engineer to join our Enterprise Integrations team located in India. This team builds and maintains critical integrations within Zapier, and partners closely with customer-facing teams to stay on the cutting edge of customer needs. This team’s mission includes:
Building and maintaining some of the most important integrations in the Zapier product
Collaborating with Customer Success, Support, and Sales teams to understand and invest in the most relevant integrations securing our most valuable deals
Ensuring continued customer satisfaction by quickly resolving any issues using these integrations
We’re hiring several Backend Engineers (mid and senior-level) to help grow our integration portfolio for our biggest customers. This is a highly technical, engineering-driven team where you'll build integrations, proactively improve integration features and reliability, handle API deprecations and migrations, and address any customer issues that may appear. If you love working with diverse APIs — REST APIs, OAuth flows, webhook design, state management, and API versioning and deprecations — debugging complex systems across service boundaries, and mentoring engineers while maintaining high standards for quality and craftsmanship, this is the team for you.
You work through AI agents, not alongside them. Your daily development workflow is built around directing and reviewing agent-written code, not writing it by hand. You have opinions about which models to use for which tasks, you've hit real failure modes and built mitigations, and your workflow is actively evolving. Bonus: you use multi-agent patterns, enable others on your team to build faster with AI, or have scaled AI impact beyond yourself.
You have deep customer empathy and thrive in the details. Zapier’s integrations are the heart of the product. With a customer-centric approach, you work with your team to improve the customer experience and participate in programs to enhance our product offerings.
You work close to the customer. You don't wait for product specs or UX research to tell you what to build. You pull customer tickets, talk to CSMs, review feedback, and use that context to drive what you ship. You think in milestone slices: what's the smallest thing I can get into production that moves us forward and teaches us something?
You own your work and yourself. You take initiative without waiting for permission and you ship fast and share early. But you also own your mistakes, your gaps, and your role in friction, openly. You say "I don't know" and "I was wrong" out loud, early, and without shame. You hold yourself to a high standard and can articulate where you've fallen short, not just where you've succeeded.
You communicate proactively in an async-first culture. You manage up and across, flagging risks, surfacing decisions, and keeping stakeholders informed without being asked. You use written artifacts, working demos, and rough prototypes as your primary communication tools, not meetings.
You believe enterprise can move fast. You've seen (or are excited to prove) that shipping to enterprise customers doesn't have to mean slow, waterfall-style cycles. You know how to balance compliance, security, and rollout considerations with tight iteration loops and rapid customer feedback. You see enterprise constraints as interesting design problems, not reasons to slow down.
Build, evolve, and maintain enterprise-grade integrations for our highest-priority customers across REST, OAuth, and webhook-based APIs, owning the full lifecycle from design through deprecation and treating agents as first-class contributors in that lifecycle.
Lead important projects from start to finish using agentic coding workflows: framing problems into agent-friendly tasks, configuring tools and context, and pairing with AI systems to generate, refactor, and migrate code while you remain accountable for correctness, safety, and long-term maintainability.
Design and operate agent “harnesses” — prompts, tools, test suites, sandboxes, and guardrails — so agents can safely modify integrations at scale (for example, dependency upgrades, refactors, or bulk bug fixes) without breaking customer workflows.
Work directly with cross-functional stakeholders (Support, Success, Sales, Product, Security, Compliance) to ensure both our integrations and our agents are solving the right problems for enterprise customers, translating their needs into clear technical work for humans and agents.
Support teammates across experience levels via pair-programming, code and prompt reviews, and mentoring on both backend fundamentals and agentic development best practices.
Participate in reviews of human- and agent-written changes, raising the quality bar for integrations and continuously documenting patterns, edge cases, and “gotchas” so that future engineers and agents can move faster with confidence.
Debug complex issues across service and agent boundaries — spanning third-party APIs, internal systems, agent workflows, and customer environments — using logs, traces, evals, and customer context (tickets, CSM feedback, error logs) to prioritize and triage effectively.
Shape integration and agent architecture across the broader organization by establishing patterns, guidelines, and reusable components that other teams can adopt.
Contribute to shared engineering infrastructure (SDKs, libraries, internal tools, CI pipelines, observability and eval frameworks) that make it easier and safer for engineers and agents to build and operate integrations at scale.
Define and track technical quality and reliability metrics (for both services and agents), using data to drive continuous improvements in performance, resilience, and developer experience.
1. Technical expertise & code quality
I understand how my team’s integration services work end‑to‑end (APIs, data flows, auth, retries, error handling) and can explain them clearly to others.
I am competent in the main backend technologies my team uses (e.g., language, framework, data stores, queues, observability stack) and can work independently on typical tasks.
I consistently ship well‑tested, well‑documented, maintainable code that follows team conventions for integrations (logging, metrics, feature flags, etc.).
I am fluent in AI-assisted, agentic development: I can break work into agent-friendly tasks, compose the right tools/skills, and use agents to generate, refactor, and migrate code — while I remain accountable for correctness, security, and long-term maintainability.
2. Ownership, planning & execution
I can take a well‑defined task or story and deliver it end‑to‑end, including tests, docs, and deployment.
I give realistic estimates, call out risks or unknowns early, and proactively update my EM/PM when delivery is at risk.
I can refine upcoming tasks enough to identify what context I need (from EM, PM, tech leads, or partner teams) and plan accordingly.
3. Problem solving & debugging
When something breaks in an integration (timeouts, auth errors, upstream API changes), I can triage, debug, and fix many issues myself by using logs, traces, and metrics.
For problems I can’t solve alone, I know which experts or teams to pull in and how to clearly summarize the problem, impact, and options.
I contribute to incremental improvements (small refactors, better error messages, test coverage) while working on my regular tasks.
4. Customer & enterprise mindset
I understand which integrations are most important for enterprise customers and factor that into how I prioritize bugs and improvements.
I’m aware of SLAs, incident processes, and on‑call expectations, and I follow them reliably when working on production issues.
I’m able to translate customer problems (often reported via Support or Success) into clear technical tickets and solutions.
5. Collaboration & communication
I communicate early and often about my progress, risks, and blockers so my team can plan around me.
I ask for help when I’m stuck, and I accept feedback on my code and approach without getting defensive.
I can participate in design discussions by asking good questions and giving thoughtful input on proposals others lead.
6. Growth & impact beyond self
I actively seek feedback from my manager and peers and use it to improve my skills and habits.
I sometimes support more junior engineers (or candidates) through pairing, answering questions, or explaining context, even if I’m not the official mentor.
I experiment with tools (including AI) that help me work more efficiently, while staying responsible for the quality of the output.
If most of these feel true most weeks, you’re likely operating at L3.
If many feel aspirational or “only when things are perfect,” you’re probably still growing toward L3.
1. Technical leadership & architecture
I am an expert in my team’s services and at least one major backend technology, and I can handle most unknowns and edge cases myself.
I regularly lead the technical design for features or projects, especially those involving complex integrations, auth models, or cross‑team dependencies.
I create or evolve integration patterns and best practices (e.g., how we structure integration adapters, rate limiting, retries, observability) and help others adopt them.
I am fluent in AI-assisted, agentic development: I can break work into agent-friendly tasks, compose the right tools/skills, and use agents to generate, refactor, and migrate code — while I remain accountable for correctness, security, and long-term maintainability.
2. Scope, ambiguity & outcomes
I work on problems where the outcome is clear but the path is not, and I break the work down into a plan that the rest of the team can execute.
I take responsibility not just for my own tasks, but for helping the team deliver its commitments, especially on critical enterprise integrations.
When delivery is at risk, I propose options and trade‑offs (scope, sequencing, technical approaches) instead of just flagging the problem.
3. Reliability, operations & incidents
I proactively look for systemic reliability risks in our integrations (e.g., dependency fragility, poor backoff, missing alerts) and drive fixes before they cause incidents.
In incidents, I can quickly evaluate impact, coordinate technical response, and make pragmatic decisions that balance risk and customer needs.
After incidents, I help drive root cause analysis and long‑term improvements, not just the immediate patch.
4. Enterprise & cross‑functional impact
I understand how our integrations affect major deals and enterprise customers and use that understanding to shape priorities and designs.
I work closely with Customer Success, Support, and Sales when needed to clarify technical feasibility, risks, and timelines for enterprise‑critical integration work.
I influence roadmap and scoping discussions by bringing a strong engineering perspective on complexity, trade‑offs, and long‑term maintainability.
5. Leading others & multiplying the team
I regularly mentor and unblock other engineers, helping them grow their debugging, design, and ownership skills.
I provide clear, actionable feedback on design docs and PRs, improving not just the code but the author’s thinking.
I often act as technical lead or feature lead for projects, coordinating work across multiple engineers or teams when needed.
6. Strategic thinking & continuous improvement
I spot patterns in bugs, incidents, or customer requests and turn them into roadmap‑level improvements (e.g., common integration libraries, platform capabilities).
I advocate for and help implement process or tooling improvements (CI, testing strategies, runbooks, observability) that make the team more effective.
I stay current on emerging technologies and industry patterns relevant to integrations (API standards, auth flows, observability, AI tooling) and bring back practical ideas for the team.
If most of these are already how you operate today – and your peers and manager would independently agree – you’re likely performing at or near L4.
If you only do these occasionally or when asked, you’re probably still solidly at L3, growing toward L4.
The anticipated application window is 30 days from the date job is posted, unless the number of applicants requires it to close sooner or later, or if the position is filled.
Even though we’re an all-remote company, we still need to be thoughtful about where we have Zapiens working. Check out this resource for a list of countries where we currently cannot have Zapiens permanently working.