Software Developer 3

YIELD SOLUTIONS GROUP LLC•Centennial, CO

9h•$150,000 - $170,000•Onsite

About The Position

This is a senior individual contributor role with a front-end emphasis and full architectural ownership. Where the Full Stack Java Engineer contributes to architectural decisions, you make and are accountable for them. You design the systems other engineers build within. You set the standards other engineers are held to in code review. You are the escalation point when a technical challenge requires judgment beyond what the team can resolve independently. We treat AI-assisted development as a core engineering discipline, not a productivity shortcut. Our approach is grounded in Nate B Jones' five levels of AI coding: engineers here are expected to work at the spec-driven and agentic levels of that framework. At the senior level, that means not only practicing these disciplines yourself but actively raising the team's fluency in them. You are the practitioner other engineers look to when they need to know how to structure a spec, evaluate agent output, or apply the delegation model to a problem they have not encountered before. You will not have direct reports. Your leverage is your technical judgment, the standards you set in review, and the clarity of your architectural decisions. You will not be handed fully-specced tickets. You are expected to shape requirements before implementation begins, identify architectural problems before a line of code is written, and resolve technical blockers without escalation.

Requirements

7+ years of professional software development with deep production experience in both Java Spring Boot and React. The additional years relative to the mid-level role reflect demonstrated architectural ownership, not just tenure.
Demonstrated ownership of architectural decisions in a microservices environment. Advisory input is not sufficient; this means decisions you made, shipped, and are accountable for.
Expert-level TypeScript proficiency in a production codebase, including advanced type system patterns and the ability to set TypeScript conventions for a team.
Deep command of microservices architecture: service decomposition, inter-service communication patterns, distributed system failure modes, API contract design, and versioning strategy.
Proven track record of designing and shipping complex, interactive front-end features at scale in React, including advanced state management patterns.
REST API design ownership at the architecture level: error handling, authentication, pagination, rate limiting, versioning, and backward-compatibility management across multiple consuming services.
Production experience with both Postgres and MariaDB, including query optimization, schema design, and migration strategy in systems that cannot tolerate downtime.
AWS experience at the architecture level: selecting services, designing for resilience, and understanding cost and performance tradeoffs, not just using services selected by others.
Terraform proficiency sufficient to design, review, and modify infrastructure definitions, not just read them.
Unit and integration testing ownership: coverage standards, test architecture decisions, and the ability to assess and improve a team's testing posture.
CI/CD pipeline design and ownership, including build optimization and deployment strategy.
Datadog or equivalent observability platform at the architecture level: instrumentation design, distributed tracing strategy, alerting framework, and SLO definition.
Production-level AI-assisted development practice at the spec-driven and agentic levels of the Nate B Jones five levels framework. Spec authoring, agent direction, and delegation model application are daily workflow, not occasional experiments.
Cross-browser compatibility expertise and front-end performance optimization at the architecture level.
WCAG 2.1 accessibility fluency, with a demonstrable track record of setting and enforcing standards across a team's output.
Comfortable setting technical direction in an agile environment with short cycles and competing priorities.

Nice To Haves

Experience in auto lending, auto refinancing, or consumer credit. Familiarity with how these products are structured, regulated, and sold shortens ramp-up time considerably.
Hands-on experience with loan origination systems, credit decisioning platforms, or lending infrastructure.
A track record of building or maintaining third-party API integrations in a platform-based product architecture.
Experience working directly with external partners or B2B clients in a product-led organization, where integrations carry contractual or SLA implications.
Familiarity with Nate B Jones' five levels of AI coding framework, or equivalent structured thinking about AI delegation, spec-driven workflows, and agentic development practice.

Responsibilities

Own architectural decisions for complex, cross-service features. This is not influence from the side; it is accountability for the outcome. When an architectural decision goes wrong, it is yours to fix.
Set and enforce front-end and full stack standards across the team: React component architecture, TypeScript patterns, state management conventions, API contract design, test coverage thresholds, and AI engineering practice.
Conduct authoritative code reviews that evaluate architectural fit, service boundary integrity, performance under load, and security posture alongside correctness. This applies with equal rigor to AI-generated code, which carries its own failure modes: hallucinated APIs, plausible-but-wrong logic, and implementations that pass tests but violate service boundaries or data contracts.
Apply and model the delegation model from Nate B Jones' five levels framework: make principled, documented decisions about which tasks to delegate to AI agents, at what level of autonomy, and where human ownership is non-negotiable. Other engineers look to you to calibrate their own judgment against yours.
Raise architectural concerns during sprint planning, design reviews, and roadmap discussions before they become production problems. At this level, that means shaping the conversation, not reacting to it.
Mentor Full Stack Java Engineers and earlier-career engineers on both technical fundamentals and AI engineering practice: spec authoring, agent output validation, delegation model application, and the discipline of treating AI instructions as engineering artifacts.
Design and build complex, interactive user-facing features in React and TypeScript that perform correctly at scale, under real load, and across the full range of supported browsers.
Author structured spec files that define problem scope, constraints, acceptance criteria, and edge cases before any implementation begins, whether by a human or an AI agent. The spec is the source of truth. AI output is an implementation candidate that must be validated against it.
Craft prompts and AI agent instructions with engineering precision: decompose problems clearly, specify constraints explicitly, and iterate based on what the output reveals about gaps in the original intent.
Design REST APIs and inter-service contracts across the microservices architecture that are stable, versioned, and defensible. You are setting contracts that other services depend on; treat backward compatibility and versioning strategy as first-class design requirements.
Manage complex application state with a clear, documented rationale that a teammate can understand and extend without your involvement.
Write unit and integration tests as part of the development cycle, not after the fact. Coverage and testability are part of the definition of done for every feature, regardless of how it was implemented.
Resolve architectural blockers independently. You are the person other engineers come to when they are stuck on something hard. You are expected to have an answer, or to produce one.
Use Datadog to monitor service health, trace requests across microservices, identify latency bottlenecks, and build alerting that catches problems before users do. At this level, you are not consuming observability infrastructure; you are designing it.
Profile and improve front-end performance with measurable targets: bundle size reduction, render bottleneck elimination, caching strategy design, and load time benchmarking that produces numbers, not impressions.
Meet and enforce WCAG 2.1 accessibility standards across your own work and the team's output. Your features set the bar others are reviewed against.
Advance the team's AI-assisted development practice. As the tooling evolves and Jones' framework progresses, you are expected to be ahead of the team, not alongside it.
Identify architectural technical debt with material velocity impact, build the business case for addressing it, and own the remediation plan through to completion.
Collaborate with product and design upstream of implementation. At this level, that means shaping requirements, surfacing constraints the product team does not know exist, and resolving ambiguity before it reaches the engineering cycle. Precise, unambiguous requirements are the foundation of both good engineering and effective AI delegation. Ambiguity discovered at spec-writing time is cheaper than ambiguity discovered in review.
Work with DevOps on Terraform-managed infrastructure design, CI/CD pipeline architecture, environment parity, and production stability for the systems you own.
Hold AI-generated code to the same security and compliance bar as any other code entering the codebase. In a regulated financial services environment processing 15,000+ applications monthly, there are no exceptions based on implementation method.
Establish documentation standards for the systems under your architectural ownership. Your documentation is the reference other engineers cite, not the artifact they bypass because it is out of date.