Senior Software Engineer - Marketing Experience

Jobvite, Inc.; United States; Remote; USD 140,000 - 170,000; Full time

Job summary

CMG Financial is seeking a senior .NET engineer to own critical systems from requirements review to production. You’ll work across modern .NET APIs, legacy .NET Framework apps, Azure, and vendor integrations, delivering reliable features at pace.

We value reproduction-first debugging, strong SQL Server expertise, and a proactive approach to refactoring and testing. This is a remote role with a focus on delivering safe, scalable software for our loan-platform stack.

Qualifications

• Deep C#/.NET experience across generations.
• Strong SQL Server skills including T-SQL, tuning and data changes.
• Reproduction-first debugging to isolate defects.
• Integration engineering with REST APIs and webhooks.
• Testing with xUnit/NUnit and mocks.
• CI/CD experience with GitHub Actions and Azure.
• Refactoring judgment for safe migrations.
• Clear technical writing and runbooks.
• Proactive ticketing and prioritized work.

Responsibilities

• Own end-to-end delivery of features across loan-officer platforms and API integrations.
• Identify and fix production issues with traceability across code, SQL, and Azure.
• Contribute to modernization through incremental, safe migrations.
• Collaborate with product, QA, and operations to ensure quality gates.

Skills

C#/.NET

SQL Server

Debugging/repro

REST APIs

Testing (xUnit/NUnit)

CI/CD (GitHub Actions/Azure)

Refactoring

Technical writing

Proactivity

Tools

GitHub Actions

Docker

Azure Functions

EF Core/EF6/Dapper/ADO.NET

Job description

The Team

We build and run the software behind CMG's marketing platform: consumer websites, loan-officer microsites, rate-lock marketing products, lead intake and routing, review and testimonial syndication, email signatures, and the background services that move loan data between our loan origination system, Salesforce, and roughly fifteen marketing SaaS vendors. The estate is seven .NET monorepos that span generations: the newest platforms are latest .NET APIs with React frontends and containerized deploys, the oldest are .NET Framework apps we are actively consolidating and retiring, and there's a lot of SQL Server underneath all of it.

The modernization is in motion, not aspirational. In the past year we consolidated everything into GitHub monorepos with GitHub Actions CI/CD, stood up a modern .NET background-job platform that legacy services are migrating onto, shipped the first phases of a program that moves applications off a shared database and onto internal APIs, and rebuilt our largest legacy product on a current stack. This role exists to keep that moving.

The Job

This is a hands-on senior role with three centers of gravity.

Ship fast against structured requirements. Product hands us structured GitHub issues with checkable acceptance criteria. The main number we watch is how quickly an accepted requirement becomes a production deployment. On this team most PRs merge the same day they open, and a bug fix routinely ships with its tests, evidence, and release notes in one pass. We are hiring for that pace, sustained, without skipping the quality gates that make it safe.

Own your systems end to end. The things you build are yours from requirements review through production. Most of the work is delivery: new capabilities on the loan-officer platforms, vendor API integrations, internal APIs that replace legacy coupling, hardening background jobs that move real loan data. And when something you own misbehaves in production, you're the one who can trace it across application code, SQL Server, vendor APIs, and Azure infrastructure and fix it at the right layer, because you understand the whole path. There's no separate ops team to hand off to; that's why our deploys are gated, evidence-backed, and reversible, and it's also why engineers here get to make real architectural decisions about the systems they run.

Modernize as you go. This is not a cleanup job, and it's not a greenfield job either; the two run side by side. The target architecture already exists in our newest platforms, the remaining tech debt has been audited and ranked into concrete backlogs (you will never be guessing where to dig), and modernization work is first-class roadmap work here, not something you sneak in between features. You'll pull the older half of the portfolio toward the standard the newer half already meets: extract services out of oversized controllers, bring schema under source control, replace database-level coupling between applications with internal APIs, retire end-of-life frameworks, and add test suites where they're missing. Every one of those changes makes the codebase faster and safer for both people and coding agents to work in, which feeds directly back into the delivery speed we care about.

How we work

We recently moved development onto Claude Code and an in-house SDLC built on GitHub issues. Our EVP of Technology, Kitt Holland, published the full system at tech.cmgfi.com/agentic-sdlc.

Every change ties to an accepted issue that carries a type and checkable acceptance criteria, and engineers send vague tickets back to product before writing code. Completion runs a validation gate, and the PR carries the evidence. Agents write a large share of the code, so your value is judgment at the gates: is the plan right, is the generated test real or tautological, does the evidence actually prove the acceptance criterion, is this safe to ship.

We expect fluency with agentic development on day one. You don't need to have used our specific tooling. You do need to know how to get reliable output from a coding agent and how to catch it being confidently wrong. If you used an AI tool to prepare your application, say so in the application; we would rather see how you drive one than have you pretend you didn’t.

What you'll need

• Deep C#/.NET experience across generations: productive in latest .NET (where new work happens) and unafraid of the .NET Framework apps, Azure Functions, and Hangfire jobs we\'re still migrating — reading unfamiliar legacy code and improving it as you pass through is a core skill here.


• Strong SQL Server skills: T-SQL (procedures, views, triggers, window functions), query and index tuning, and disciplined production data changes. Our data access spans EF Core, EF6, Dapper, and raw ADO.NET; you should be able to read and safely change all of them.


• Reproduction-first debugging. You reproduce before you fix, you can tell a code defect from a config, data, or infrastructure problem, and you can show your work.


• Integration engineering: REST APIs and webhooks, OAuth/JWT, retries and idempotency, file feeds, and the patience to work with imperfect vendor APIs. Our current set includes Salesforce, BytePro, DocuSign, Stripe, Cloudinary, Uberall, and Testimonial Tree, among others.


• Testing habits that survive legacy code: xUnit/NUnit with mocking, regression tests that fail on the old behavior, and the will to bootstrap the first test project in a solution that has none.


• CI/CD and Azure operations: GitHub Actions, Docker to App Service, Azure Functions, Application Insights, deploy sequencing (database before code), feature flags, and release promotion from a dev branch through to main.


• Refactoring judgment: blast-radius analysis before touching shared objects, incremental strangler-style migrations, and parity testing with a rollback path for anything risky.


• Clear technical writing. Requirements clarification, PR narratives, runbooks, and rules files are daily output here, and they are how both the team and the agents stay effective.


• Proactivity. The best people in this role file their own tickets: they notice the missing index, the silent failure path, the credential sitting in source, and turn it into scoped, prioritized work without being asked.

Nice to have

• Mortgage or fintech domain experience (rate locks, LOS data, NMLS compliance)


• Frontend range: React/TypeScript on the new stack; jQuery, Knockout, and webpack on the old one


• Terraform, Okta, or headless CMS (Kentico Kontent) experience

How you'll be measured

Two things above the rest: cycle time from product-accepted requirement to production deployment, and the trend line on the codebases you own — fewer EOL frameworks, more tests running in CI, fewer places where an agent or a new engineer gets trapped.

SUPERVISORY RESPONSIBILITIES:

Direct Reports: N/A

PHYSICAL and ENVIRONMENTAL CONDITIONS:

This role operates in an ADA compliant office environment, utilizing typical office equipment and tasks including computer work. The position may involve partial stationary positions and moving throughout the day. Flexibility to work overtime to meet project deadlines is required.

COMPENSATION:

Base Compensation Information– This role is a remote position that is currently allocated for candidates within geographic regions that do not currently require base wage disclosure. The compensation range for this position will be provided upon request.(Due to their geographic location, residents of the states of CA & CO, and for NY, etc. are excluded from this role at this time.)