Cardiff lends to small businesses. Since 2004 we've funded more than $12 billion across the country, to businesses in logistics, healthcare, construction, professional services, and plenty in between. We're building our own underwriting technology, and we still answer the phone; our customers need capital fast, and they want a straight answer from a person who can actually help.
Location: Remote (U.S.)
Employment Type: Full-time
Department: Engineering
Reports to: Director of Engineering
Salesforce is where Cardiff's business is recorded: every lead, deal, merchant, and funding decision runs through it. It also carries a decade of application logic that was built there because Salesforce was the only place to build it. That's no longer true, and it's holding back what we can automate.
Today our average turnaround from lead to funded is 24 business hours; our goal is minutes. You're the engineer who writes the code that gets us there: the integration layer between Salesforce and our own platform, and the services that take over what Apex and Flow are doing today.
We are all in on AI, and we're deliberate about where it runs.
Automation lives outside Salesforce. We build our own agents against our own AWS environment and the Cardiff API. We are not buying Agentforce, and we're not solving problems by stacking more managed packages on the org. When there's work to automate, the answer is usually an external service or agent calling Salesforce through the API, not another trigger.
Salesforce and Slack are the system of record and where our people work. They hold the truth and they're the interface for the human team. Application logic moves out to AWS over time, where we can test it, version it, and let agents drive it. You'll write plenty of Apex; you'll also write the code that makes some of it unnecessary.
Coding agents are the default way we build. Claude Code, Cursor, Codex, or whatever is best that month. We expect you to ship several times faster than you would have two years ago, and to read what the model produces before it merges. Judgment is the part of the job that doesn't get automated.
If you've been waiting for permission to work this way, you'll like it here. If your instinct is to solve everything inside the platform, this will be a frustrating seat.
You'll build on top of Salesforce and build the path off it, often in the same week. That means Apex, LWC, and SOQL where they're the right tool, and Python services on AWS calling Salesforce through its APIs where they're better. You'll own the integration layer that connects the org to the Cardiff API, Snowflake, our agent platforms, and our lender partners.
You'll report to the Director of Engineering and work alongside our Salesforce Administrator, who owns configuration and data governance; you own code, integrations, and deployment. The team is small and senior; you'll work directly with the stakeholders in Sales, RevOps, Underwriting, and Marketing rather than through a layer of tickets.
Apex, LWC, and SOQL. Triggers, async processing, batch jobs, platform events, and custom components, written to be read and tested
The integration layer. REST and platform-event integrations between Salesforce, the Cardiff API, Snowflake, Twilio, our agent platforms, and lender APIs
The migration path. Moving logic out of Apex and Flow into services on AWS, and retiring the in-platform version cleanly when it's replaced
Release engineering. Source-driven development with sfdx, version control, and CI/CD, so releases are boring
Data and performance. Governor limits, bulk-safe code, and queries that hold up as volume grows
Production support for what you build. When something you shipped breaks, you own the fix and the write-up
First 30 days: You've mapped the org's code and integration surface: what the triggers do, where the Apex is, what talks to what, and where the risk sits. Your first pull requests are in production.
First 90 days: Delivering against stakeholder requests on a predictable cadence. At least one integration built or rebuilt against the Cardiff API. The path off one significant piece of in-platform logic is scoped, with a real date.
First year:
Two or more meaningful workloads moved out of Apex or Flow into services on AWS, with the Salesforce side retired
An integration layer people trust: it handles volume, fails loudly, and recovers
Deployments that go out without drama, through source control and CI/CD
A codebase measurably smaller and better tested than the one you inherited
3+ years developing on Salesforce, with production ownership of what you shipped
Strong Apex and SOQL: triggers, async patterns (Batch, Queueable, Platform Events), governor limits, and bulk-safe design
Lightning Web Components and modern front-end fundamentals
REST and platform-event integrations between Salesforce and external systems, including auth, error handling, and retries
Source-driven development: sfdx, Git, sandboxes, and CI/CD rather than changes made straight in production
Real programming outside the Salesforce ecosystem: Python or TypeScript, SQL, and cloud deployment (AWS preferred)
Coding agents as your primary way of building; Claude Code, Cursor, Codex, or similar, with a specific example from the last six months of delivering something several times faster than you could have without them
The engineering fundamentals to recognize when AI output is wrong
Nice to have:
Experience decomposing a Salesforce org: moving functionality out to services and retiring the in-platform version
Fintech, lending, or MCA data models; Fundingo
Snowflake or another warehouse, and event-driven architectures
Salesforce Platform Developer I or II
LLM APIs, agent orchestration, or RAG in production
We weigh what you've shipped in the last 90 days more heavily than the brand on your resume. Show us code.
You ship: a working v1 in production beats a polished v1 in a sandbox.
You work independently and communicate proactively; when something is blocked, you say so the same day, in writing, with what you need.
You'd rather delete a trigger than add one.
You're comfortable telling a stakeholder that what they asked for isn't what they need, and you can explain why without jargon.
Have a legacy mindset about the platform: Salesforce as the place all logic belongs, rather than a system of record
Would rather buy Agentforce or another managed package than build against APIs
Only want to work inside the Salesforce ecosystem and would rather not write Python or touch AWS
Prefer highly structured corporate environments, or need extensive direction and oversight
Dislike fast-changing priorities
Use AI tools to assist your old workflow, rather than having rebuilt your workflow around them
Base salary: $110,000
Performance bonus of up to $20,000, tied to delivery and business outcomes
Medical, dental, and vision coverage
401(k) plan
Flexible PTO and observed holidays
Remote-first, with support for your home-office setup
Email AI-Eng@cardiff.co with:
A link to your GitHub, or code you can show us
The most complex thing you've built on Salesforce: what it does, why it needed code rather than configuration, and how it's tested
A specific example from the last six months of using AI tooling to ship faster, and what you caught in its output before it merged
Cardiff, Inc. is an Equal Opportunity Employer. We are committed to creating a diverse and inclusive workplace and do not discriminate on the basis of race, color, religion, sex, national origin, age, disability, veteran status, sexual orientation, gender identity, or any other characteristic protected by applicable law.
RevOps Roles analysis
Benefits, tools, and company context we extract from the full posting and classify, so you can scan in seconds what the write-up buries in prose.
Opens in a new tab