Senior Salesforce & Integration Engineer

VTS•New York, NY

47d•$150,000 - $190,000•Onsite

About The Position

VTS runs a complex, high-volume revenue motion — Salesforce CPQ feeding NetSuite via middleware, with mid-contract amendments involving upsells, cross-sells, volume changes, downgrades, and product churn happening continuously. The integration layer that connects these systems is functional but manual-heavy, underdocumented, and not built to scale. Furthermore, our CRM and CPQ system requires customization in order to optimize deal workflows to ensure accuracy and timely contract execution. This is not a Salesforce admin role with a developer title. We need someone who writes clean Apex, understands how CPQ order data needs to land in an ERP, knows what good middleware design looks like, and treats release management as a professional discipline — not an afterthought. Alongside our RevOps system team and Salesforce Architect, you'll work closely with our Finance and Sales teams. You will be one of the internal technical voice that evaluates and challenges what those partners propose — knowing when to push back when something is wrong.

Requirements

Salesforce CPQ knowledge with real hands-on experience — amendment flows, product configuration, pricing rules, renewal logic. Not a generalist SF developer who has touched CPQ.
Apex development: you write clean, testable code. Test classes are part of your practice, not something you bolt on at the end. 90%+ coverage is your floor.
Integration experience: you understand how Salesforce data needs to be structured for ERP consumption, you've worked with middleware (Celigo, Workato, Boomi, or equivalent), and you know what a well-designed field mapping looks like
Release management: you've used Gearset, Copado, or an equivalent Git-based deployment tool in a real environment. You understand branching strategy and can set one up, not just follow one
NetSuite literacy: you don't need to be a NetSuite developer, but you need to understand the data model well enough to design an integration that lands correctly on the ERP side
Awareness of where AI tooling is relevant in the Salesforce ecosystem — Agentforce, Einstein, or AI-augmented workflow automation — and where it isn't

Responsibilities

Own the technical customization and development of Salesforce — LWCs, Apex classes/triggers etc along with flows
Manage the scaling of custom objects that drive pre/post sales teams in meeting customer needs and internal workflow management
Write and maintain Apex triggers, classes, and flows that support Salesforce and CPQ business logic — with test classes that hit 90%+ coverage as a floor, not a ceiling
Partner with third-party implementation firms on the integration build and growth connecting Salesforce CPQ to NetSuite — be the internal technical reviewer, not just the observer
Own the internal integration layer as it matures: field mappings, error handling, retry logic, and monitoring
Keep business logic out of the middleware — understand why that principle matters and enforce it in design decisions
Help define what a middleware-agnostic data model looks like and make decisions today that don't create technical debt tomorrow
Understand how integration data feeds Revenue and Billing systems downstream — you don't need to be a rev rec expert, but you need to know what breaks when the data is wrong
Create integrations with other tools in the overall revops stack as needed to support all business units to enhance processes and data reliability
Understand and leverage AI (Claude Code) toolsets to increase velocity and breadth of development leveraging SF APIs and MCP
Own and enforce a proper release process — Gearset or Copado, Git-based version control, branching strategy, and environment management across dev, QA, UAT, and production
Eliminate change set deployments. Full stop. If something is being deployed via change set after you join, that's a gap to fix, not a process to accept
Write test classes that test behavior, not just coverage percentages — and hold the bar on code quality in any code you review or inherit
Document everything you build in plain language — architecture decisions, field mappings, integration flows, known edge cases. You own this environment; your documentation should mean someone else could too
Require the same release discipline from third-party partners — their code goes through the same pipeline, not a separate ad-hoc process