Software Developer

Build systems businesses can depend on.

Help design, build, secure, optimize, and evolve the architecture behind Brilliance One, a connected CRM + ERP + CMS business operating system.

Developers at Brilliance work across .NET applications, APIs, SQL Server, integrations, automation, security, performance, infrastructure, and user-facing experiences. We are looking for engineers who care about clean architecture, practical solutions, data integrity, maintainability, and what happens after the code reaches production.

Explore the Role View Technology Stack
.NET & C# • SQL Server • API-first • Security-focused
Software Developer career at Brilliance One

Role Overview

Engineer the platform. Not just the feature.

We are looking for a .NET Software Developer who can help design, build, maintain, troubleshoot, and improve the applications, APIs, databases, integrations, and services that make Brilliance One work.

Applications

Application Development

Build and improve web applications, services, internal tools, modules, and customer-facing capabilities using modern .NET development practices.

Data

Database Engineering

Design schemas, write efficient SQL, develop stored procedures, troubleshoot data issues, and improve database performance while protecting integrity.

Architecture

APIs, Security & Reliability

Build secure and maintainable APIs and services with attention to authorization, validation, auditing, performance, error handling, and long-term supportability.

Engineering Philosophy

Solve today's problem. Protect tomorrow's system.

Brilliance One is designed to grow across modules, customers, industries, integrations, data, and increasingly complex workflows. Engineering decisions need to support that growth without making the platform unnecessarily difficult to understand or maintain.

  • Keep architecture understandable
  • Prefer maintainable solutions over clever ones
  • Design APIs deliberately
  • Protect data throughout the application stack
  • Think about performance before it becomes a crisis
  • Write code another developer can support
  • Measure performance instead of guessing
  • Test meaningful business scenarios
  • Document important architectural decisions
  • Improve existing systems instead of only adding features

Developer Mindset

Think beyond the ticket.

Shipping a feature is only part of engineering. Good development also considers security, performance, supportability, diagnostics, data integrity, backwards compatibility, testing, deployment, and the developers who may need to maintain the code later.

We want engineers who understand the requirement in front of them while still considering the larger system around it.

What You’ll Help Build

One connected platform. Many engineering problems to solve.

Brilliance One extends across customer relationships, operations, digital experiences, communications, workflow automation, reporting, security, commerce, and specialized business processes.

CRM & Sales Accounts, contacts, leads, opportunities, pipelines, customer history, activities, tasks, and relationship workflows.
ERP & Operations Products, inventory, purchasing, vendors, projects, scheduling, accounting, point of sale, and operational processes.
CMS & Digital Experience Websites, content, forms, portals, knowledge resources, customer experiences, and API-driven delivery.
Communications Email, SMS, MMS, campaigns, customer conversations, automated messaging, preferences, and communication history.
Automation & Intelligence Workflows, business events, notifications, integrations, reporting, analytics, and AI-assisted capabilities.
Industry Modules Specialized capabilities that extend the core platform into industries with unique workflows and operational requirements.

Technology Stack

Microsoft backend. Standards-based web development.

The role spans backend development, database engineering, APIs, frontend technologies, integrations, deployment, testing, performance, and production troubleshooting.

Backend

.NET & C#

  • C#
  • .NET
  • ASP.NET Core
  • Web applications
  • Application services
  • REST APIs

Data

SQL Server

  • Relational database design
  • Complex SQL queries
  • Stored procedures
  • Indexes and query performance
  • Data integrity
  • Database troubleshooting

Frontend

Web Technologies

  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • Responsive interfaces
  • Accessible web development

APIs

Integrations & Services

  • Internal APIs
  • Third-party APIs
  • Partner integrations
  • Authentication and authorization
  • Error handling
  • Versioning and reliability

Infrastructure

Hosting & Deployment

  • IIS
  • Application configuration
  • Deployment practices
  • Monitoring and diagnostics
  • CI/CD familiarity
  • Azure knowledge is helpful

Quality

Testing & Validation

  • Unit testing
  • Integration testing
  • Scenario testing
  • Regression awareness
  • Debugging
  • Performance validation

API-First Development

Build capabilities that can be used beyond one screen.

APIs are a core part of the Brilliance One architecture. Developers should think about reusable business capabilities, clear contracts, secure access, predictable responses, validation, and how functionality may be consumed by multiple applications or integrations.

  • Design clear request and response contracts
  • Keep authorization requirements explicit
  • Validate inputs consistently
  • Return predictable error behavior
  • Consider backwards compatibility
  • Document endpoints and expected behavior
  • Design for internal and external integrations
  • Think about rate limits, reliability, and abuse prevention where appropriate

Platform Thinking

Build capabilities, not isolated pages.

A feature may eventually be used by a web interface, portal, integration, mobile experience, automation, or another application.

Separating business capability from presentation helps the platform remain more extensible as Brilliance One grows.

Database Engineering

Correct data. Fast access. Predictable behavior.

Database work is a core engineering responsibility at Brilliance. Developers should understand how application decisions affect queries, stored procedures, indexing, transactions, integrity, scalability, and customer experience.

Design

Data Modeling

Design tables, relationships, keys, indexes, and data structures that support the business requirement while remaining understandable and maintainable.

Performance

Query Optimization

Investigate execution behavior, identify inefficient queries, improve indexing, reduce unnecessary work, and validate performance with evidence.

Integrity

Protect the Data

Consider validation, concurrency, transactions, tenant boundaries, auditability, and failure scenarios before data reaches production.

Security Engineering

Security belongs inside normal development.

Brilliance One handles important customer and operational information. Developers are expected to consider authentication, authorization, validation, auditing, database access, APIs, logging, error handling, and secure defaults while designing and implementing features.

  • Secure coding practices
  • Authentication and authorization awareness
  • Role and permission enforcement
  • Safe input validation
  • Responsible data handling
  • Logging and auditability
  • API security
  • Database access controls
  • Testing security-sensitive workflows
  • Avoid exposing sensitive implementation details

Security Mindset

Security is an engineering responsibility.

Secure software is not created by waiting for a security review after development is complete.

Security decisions happen during architecture, database design, API development, coding, testing, logging, deployment, configuration, and production support.

Performance Engineering

Measure first. Optimize what matters.

Performance work should be based on evidence. Developers are expected to investigate where time and resources are actually being spent before deciding what needs to change.

Application Code

Identify unnecessary work, excessive allocations, repeated operations, blocking behavior, and inefficient application patterns.

SQL

Review query execution, indexes, stored procedures, result sizes, joins, filters, and data-access behavior.

APIs

Measure endpoint behavior, response time, payload size, downstream dependencies, and failure paths.

Frontend

Consider page weight, network activity, rendering behavior, accessibility, and perceived responsiveness.

Infrastructure

Understand how application configuration, hosting, services, resources, and deployment choices affect behavior.

Regression

Make sure improvements in one area do not quietly create problems somewhere else.

Responsibilities

Own the code beyond the commit.

Developers contribute across design, implementation, testing, deployment, troubleshooting, documentation, and ongoing improvement.

Application Development

Design, develop, maintain, and improve applications and services using .NET, ASP.NET Core, C#, HTML, CSS, JavaScript, and TypeScript.

Database Engineering

Design and optimize schemas, queries, stored procedures, indexes, and data-access patterns while protecting performance and data integrity.

API Development

Build and maintain secure APIs for internal applications, websites, integrations, customer systems, and partner services.

Integrations

Connect Brilliance One with external systems while considering authentication, reliability, validation, retries, failure handling, and maintainability.

Code Quality

Participate in code review, write meaningful tests, debug defects, improve existing code, and help maintain consistent development practices.

Performance

Identify bottlenecks across application code, SQL, APIs, frontend behavior, and infrastructure while improving scalability and responsiveness.

Deployment

Help deploy applications safely, manage configuration, validate production behavior, monitor systems, and respond when something does not behave as expected.

Production Support

Investigate real-world issues, identify root causes, protect customer data, communicate findings, and improve systems so recurring problems are less likely.

Documentation

Maintain useful technical documentation, API references, architecture notes, deployment guidance, setup instructions, and development procedures.

Collaboration

Work with product, customer service, leadership, design, marketing, and other developers to understand requirements and create practical solutions.

Technical Debt

Recognize when existing code or architecture is creating unnecessary risk or complexity and help improve it as part of responsible platform development.

Continuous Improvement

Look for opportunities to improve development practices, architecture, diagnostics, performance, testing, security, and maintainability.

Skills & Qualifications

Technical depth. Practical judgment.

We value technical ability, but strong developers also need communication, ownership, curiosity, debugging skill, and the judgment to choose appropriate solutions.

Development

Core Development

  • Proficiency with C#, .NET, and ASP.NET Core
  • Experience building web applications and services
  • Strong debugging and problem-solving ability
  • REST API development experience
  • Clean and maintainable coding practices
  • Ability to work with and improve existing applications

Data

Database & Infrastructure

  • Strong SQL Server experience
  • Complex SQL queries and stored procedures
  • SQL performance optimization
  • Relational database design
  • IIS deployment and configuration
  • Azure and DevOps familiarity is helpful

Web

Frontend & Quality

  • HTML, CSS, JavaScript, and TypeScript
  • Frontend and backend integration
  • Visual Studio and Git-based version control
  • Unit and integration testing
  • Attention to usability and accessibility
  • .NET MAUI or mobile development is a plus

Qualifications

Experience matters. Problem solving matters more.

Formal education and professional experience are valuable, but the ability to reason through difficult problems, write maintainable software, communicate clearly, and continue learning is equally important.

Education

Bachelor’s degree in Computer Science, Software Engineering, a related field, or equivalent practical experience.

Experience

One or more years of professional software development experience using .NET technologies is preferred.

Problem Solving

Strong analytical ability and willingness to investigate beyond the obvious symptom to find the underlying cause.

Communication

Ability to explain technical decisions, document work, and communicate effectively with technical and nontechnical teammates.

Ownership

Willingness to take responsibility for code through development, testing, deployment, monitoring, and production support.

Continuous Learning

Comfort learning new platform capabilities, architecture patterns, technologies, security practices, and development techniques.

Development Process

Understand. Build. Validate. Improve.

Strong engineering starts before code is written and continues after the change reaches production.

1

Understand

Understand the business requirement, existing behavior, architecture, affected data, security implications, integrations, and expected outcome before changing the system.

2

Build & Validate

Implement maintainable code, test expected and edge-case scenarios, verify integrations, review performance, and protect existing behavior.

3

Ship & Improve

Deploy responsibly, verify production behavior, monitor results, document important changes, respond to issues, and improve the platform based on what is learned.

Who Fits This Role?

Curious enough to investigate. Disciplined enough to finish.

This role is best suited for developers who enjoy understanding how systems work, solving unfamiliar problems, improving existing code, and taking responsibility for the quality of what reaches production.

  • You investigate before guessing
  • You care about why a problem occurred, not only how to hide the symptom
  • You can work inside an existing architecture
  • You are willing to improve code you did not originally write
  • You think about security and data before shipping
  • You test your own work before handing it off
  • You communicate when requirements or risks are unclear
  • You take production problems seriously

Engineering Ownership

“It works on my machine” is not the finish line.

Software is successful when it behaves correctly for the people and businesses using it, performs reliably in production, protects their data, and can be maintained as the platform evolves.

Developers are expected to stay engaged through testing, deployment, troubleshooting, and improvement when their work reaches the real world.

Career Growth

Build deeper expertise. Take on larger systems.

As Brilliance One grows, developers can expand their responsibilities across architecture, APIs, databases, security, performance, integrations, modules, infrastructure, and technical leadership.

Develop

Broaden Your Technical Depth

Work across application development, databases, APIs, frontend systems, integrations, performance, infrastructure, and security.

Own

Take Responsibility for Larger Areas

Strong engineers can grow into ownership of modules, services, architecture decisions, integrations, performance initiatives, and complex platform capabilities.

Lead

Grow Into Technical Leadership

Developers who consistently demonstrate technical judgment, ownership, communication, and execution may have opportunities to mentor others and take on greater architectural or management responsibility.

Compensation & Employment

A development role with room to grow.

This position includes base compensation, remote flexibility, defined development expectations, and opportunities for greater technical or leadership responsibility as Brilliance grows.

Base Salary Yes
Employment Type W-2 employee
Remote Yes
Performance Expectations Defined development and performance expectations apply
Weekly Goals Yes
Advancement Opportunities for technical leadership, management, or greater architectural responsibility
Company Benefits Benefits may be added as they become available
Growth Opportunity Responsibilities can expand as the platform, architecture, customer base, and engineering team grow

Engineering at Brilliance One

Build the system. Own the outcome.

If you enjoy solving complex problems, working across applications and databases, building APIs, improving performance, thinking about security, and creating software designed for long-term use, we would like to hear from you.

Apply or Introduce Yourself View All Careers

Brilliance One • .NET Engineering • API-First • Built in the USA