About Cardiff

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

Why This Role Matters

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.

How We Build

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.

The Role

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.

What You'll Own

• 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

What Success Looks Like

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

Required Qualifications

• 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.

Who You Are

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.

This Role May Not Be a Fit If You

• 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

Compensation and Benefits

• 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

How to Apply

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.