Software Engineer

Compyl

Get hot jobs first on Telegram

New positions appear faster in our channel

Location: United States
Job Type: full-time
Work Format: 🌍 Remote
Salary: $100K – $140K
Posted: November 8, 2026

Job Description

The salary offered will be determined by the candidate's location, qualifications, experience, and education and may be outside of this range. Final compensation packages are competitive and in line with industry standards, reflecting a variety of factors, and include a comprehensive benefits package.

Overview Application

Software Engineer

Agentic AI Compyl · Enterprise Governance, Risk & Compliance · New York, NY compyl.com

ABOUT COMPYL

Compyl is an enterprise-grade Governance, Risk, and Compliance (GRC) platform helping organizations automate risk management, compliance, and audit readiness across complex security environments. Based in NYC, our platform connects with hundreds of security tools to simplify evidence collection, streamline workflows, and give teams a more modern way to manage GRC at scale. We are building for speed, scale, and impact. Our culture is rooted in accountability, curiosity, and a strong bias toward execution. We value people who take ownership, move fast, and care deeply about building meaningful products that solve difficult problems.

THE ROLE

As a Software Engineer, you will architect and build the heart of the Compyl platform. This team is responsible for our most critical feature set: an Agentic AI system that actively manages, remediates, and plans GRC workflows autonomously. You will not be building "bolt-on" AI chat features. You will be designing intelligent systems that take autonomous action within our robust C# / .NET and Blazor ecosystem.

REQUIREMENTS

C# / .NET Deep mastery of the .NET ecosystem, CQRS, and Onion Architecture (Controller → Service → Repository). You know how to design scalable systems that can handle complex state and AI orchestrations.
Proven experience building agentic workflows, orchestrating LLMs to take action, parse structured data, and execute multi-step logic safely.
Strong experience with Blazor WebAssembly/Server. You understand component-driven architecture, strict separation of logic (.razor.cs), and building highly interactive UIs.
AI-Native Workflow Proficiency in Cursor, Claude Code, or Codex is mandatory. You leverage AI IDEs to automate boilerplate and write faster, cleaner code.
You thrive in high-velocity environments, balancing rapid shipping with necessary architectural guardrails.

HOW WE WORK

At Compyl, engineering is expected to move with urgency while maintaining high standards for quality, performance, and security. We care about building systems the right way, but we also know how to make pragmatic decisions that keep the business moving. A few principles that guide our team:

Frontend & API Rigor: No inline styling — component-specific .scss only. Strict adherence to OpenAPI 3.1.1 standards with mandatory XML documentation for all public endpoints.
The Campground Rule: We believe in leaving the codebase better than we found it. Engineers proactively address technical debt and clean up nullable warnings daily.
Accountability & Extreme Ownership: We ship code daily. While we have solid guardrails and automated testing (Playwright) in place, you are empowered to own your features from the IDE to production.

WHY COMPYL

Joining Compyl means working on meaningful technical challenges inside a growing SaaS company operating at the intersection of security, compliance, and automation. You'll have the chance to influence core architecture, work alongside a team that values execution, and help build the foundation for the next stage of our platform.

Salary: $100,000 to $140,000 - Actual compensation may vary based on factors such as equity allocation, prior training, transferable skills, work experience, location, and evolving business needs.
Meaningful equity in a fast-growing company
Uncapped earnings potential
Remote-first culture with flexible PTO
Access to a highly supportive, execution-focused leadership team
Opportunity to shape the growth and foundation of a high-impact SaaS product
A team that values collaboration, accountability, and transparency

Equal Opportunity Statement

Compyl is an equal opportunity employer and does not discriminate on the basis of race, color, religion, national origin, ethnicity, sex (including gender identity, pregnancy, and sexual orientation), age, disability, veteran status, marital status, or any legally protected status under federal, state, or local law.

Applicants with disabilities may be entitled to reasonable accommodation under the Americans with Disabilities Act (ADA) or applicable state/local laws. To request accommodation during the application process, please contact Jaymes Nowicki, Head of Talent Acquisition.

🎯 Who is this job for?

This role is suitable for a Senior Software Engineer with deep expertise in C#/.NET, CQRS, Onion Architecture, Blazor, and AI-native development workflows using tools such as Cursor, Claude Code, or Codex.

The ideal candidate should be skilled in designing scalable systems and agentic AI workflows that orchestrate LLMs, process structured data, and safely execute autonomous, multi-step actions.

They should be familiar with owning features end to end, building interactive Blazor interfaces and OpenAPI-compliant APIs, maintaining automated tests, addressing technical debt, and delivering secure, high-quality software in a fast-paced environment.

💬 Potential Interview Questions

How would you apply CQRS and Onion Architecture in a C#/.NET GRC platform?

I would separate commands that change state from queries that read optimized projections, keeping domain logic independent from infrastructure. Controllers would delegate to application services or handlers, while repositories and external integrations remain behind interfaces in the infrastructure layer.

How would you design an agentic workflow that allows an LLM to remediate a compliance issue safely?

I would constrain the agent with typed tools, explicit permissions, validation rules, and a state machine for multi-step execution. Every action should be auditable, idempotent where possible, subject to policy checks, and require human approval for high-impact operations.

How would you ensure structured and reliable output from an LLM orchestration?

I would use strict JSON schemas or strongly typed contracts, validate responses before processing, and implement retries with bounded limits for transient or malformed outputs. The workflow should fail safely and preserve the original input, model response, and validation errors for observability.

How would you manage long-running, multi-step AI workflows in a .NET application?

I would persist workflow state and checkpoints so execution can resume after failures rather than relying on in-memory state. A durable queue or workflow engine, idempotency keys, retry policies, timeouts, and correlation IDs would support reliable execution and monitoring.

What practices would you use to secure autonomous actions against enterprise security tools?

I would apply least-privilege credentials, tenant isolation, scoped tool permissions, input validation, and allowlists for supported operations. Secrets should be stored in a secure secret manager, while all requests, decisions, approvals, and results should be recorded in tamper-resistant audit logs.

How would you structure a Blazor application using component-driven architecture?

I would keep reusable UI components focused on presentation and interaction, with business logic in code-behind files or dedicated services rather than inline in Razor markup. State management, asynchronous loading, validation, and error handling should be explicit and testable, with component-specific SCSS for styling.

What are important considerations when choosing between Blazor WebAssembly and Blazor Server?

Blazor WebAssembly reduces server connection requirements and can improve client-side responsiveness, but it requires careful handling of download size, API security, and offline limitations. Blazor Server simplifies centralized execution but requires reliable connections and careful management of circuit capacity and latency.

How would you design and document APIs that comply with OpenAPI 3.1.1?

I would define consistent resource models, error responses, pagination, authentication requirements, and operation metadata in the OpenAPI contract. Every public endpoint would include XML documentation, clear request and response schemas, validation rules, and examples that match the implemented behavior.

How would you test an agentic workflow and its integrations?

I would unit test domain rules, command handlers, tool adapters, and parsing logic independently, then use integration tests for persistence and external service boundaries. Playwright would validate critical end-to-end user journeys, while deterministic model fixtures and failure scenarios would test orchestration without depending on live LLM behavior.

How would you use AI IDE tools such as Cursor, Claude Code, or Codex responsibly?

I would use them to accelerate scaffolding, refactoring, test generation, and documentation, while treating generated code as untrusted until reviewed. I would verify security, correctness, architectural alignment, nullable-reference warnings, test coverage, and licensing or data-handling implications before merging.

📋 Job Summary

Compyl is hiring a Software Engineer to build agentic AI systems that automate and manage enterprise Governance, Risk, and Compliance workflows. You’ll design scalable services and interactive applications using C#, .NET, CQRS, Onion Architecture, Blazor, OpenAPI, Playwright, and AI development tools such as Cursor, Claude Code, or Codex. This is a full-time, 100% remote role within the USA, offering a $100K–$140K base salary plus meaningful equity. Join a fast-growing SaaS company to shape critical architecture, solve challenging automation problems, and work with an execution-focused team.