Dotnet Software Engineer

Our team designs, develops, tests, and maintains business applications using C# and

the .NET platform. The work includes both development of new capabilities and ongoing

enhancement and modernization of existing applications.

The work frequently requires an engineer to begin with relatively broad requirements,

clarify the problem and desired outcome, evaluate implementation options, and drive the

work through completion. Regular communication and check-ins with the internal team

are expected throughout that process.

Effective augmentation of this work requires more than familiarity with particular

frameworks. Sound technical judgment, strong communication, and an inclination to seek,

establish, and maintain alignment on goals and requirements are especially important.

Core Capabilities

C# and .NET Software Engineering

Work performed by the team includes:

• Developing applications using modern C# and .NET
• Developing web applications using ASP.NET Core, including the MVC applicationmodel
• Applying object-oriented software design principles appropriately
• Designing code for maintainability, testability, and clear separation of responsibilities
• Refactoring existing software safely and incrementally
• Using asynchronous programming techniques in .NET
• Applying functional programming concepts pragmatically where they improve the design
• Evaluating technical tradeoffs rather than mechanically applying patterns or practices

**Working effectively in Visual Studio, with VS Code also used in the development environment

A resource augmenting this work should be proficient in C# and demonstrate solid
software engineering practices rather than simply being able to implement functionality.**

Testing and Quality

Automated testing is an important part of the team s development practices. Relevant

capabilities include:

Unit testing

Designing software for testability

Using mocks, fakes, or other test doubles where appropriate

Integration testing

End-to-end testing

Choosing an appropriate level of testing based on the behavior being verified

Requirements, Judgment, and Communication

The nature of the work requires engineers who can:

Listen carefully and communicate clearly

Understand the goal behind requested work rather than treating stated requirements as implementation instructions

Identify ambiguity and clarify requirements and assumptions

Work independently from relatively broad requirements

Maintain regular communication with the internal team while doing so

Proactively seek alignment when requirements, assumptions, or technical direction are unclear

Identify and communicate risks, dependencies, alternative approaches, and significant tradeoffs

Accept technical direction and incorporate feedback constructively

Recognize when a decision can be made independently and when broader

technical alignment is needed

These capabilities are important when evaluating potential staff augmentation resources.

Additional Relevant Capabilities

Actor Model and Akka.NET

Some applications use Akka.NET and Actor Model techniques for stateful, concurrent, or

distributed application design.

Deep Akka.NET expertise is not required for every engagement, but useful experience

includes:
Familiarity with Actor Model concepts
Direct experimentation or development experience with Akka.NET
Experience with messaging, concurrent systems, distributed applications, or other

stateful application architectures

A resource with a strong software engineering background and some practical exposure to

Akka.NET can be appropriate even without extensive production Akka.NET experience.

Front-End Development

Some .NET work includes significant browser-based application development. Depending

on the need, front-end work may be performed by the same engineer or by a separate

resource.

Relevant experience includes one or more modern component-based front-end

technologies such as:

Vue.js

React

Blazor WebAssembly

Comparable modern front-end frameworks

Supporting capabilities can include:

TypeScript and JavaScript

HTML and CSS

Browser application architecture

Integration with HTTP/REST APIs

Full-stack capability is useful, but it is not necessary for every .NET augmentation need.

Back-end and front-end development can be staffed separately when appropriate.

Other Useful Experience

Depending on the work, experience with the following can also be useful:

Dependency injection and inversion of control

REST API design and integration

Relational database development and SQL

Structured logging and application observability

JSON and other serialization formats

Protocol Buffers

Git source control

ReSharper or comparable refactoring tools

Experience administering CI/CD or deployment infrastructure is not a requirement for this role profile.
Most Important Characteristics

When considering a resource for this work, the strongest indicators of fit are:

1. Proficiency with C# and sound software engineering practices.

2. Good technical judgment.

3. Strong listening and communication skills.

4. A tendency to seek understanding of the goal and requirements before and during implementation.

5. The ability to work independently without becoming disconnected from the internal team.

6. Consistent use of appropriate testing and design practices.

7. Willingness to raise questions, risks, and disagreements early enough for them to be useful.

Requirements

C# .NET / Modern .NET ASP.NET Core / MVC Strong Software Engineering / OOP Unit + Integration Testing Good Communication Requirement Analysis / Problem Solving Ability to Work Independently

Disclaimer: This job posting has been aggregated from external source. Role details, content, and availability are subject to change. Applicants are advised to confirm the latest information directly on the company website before applying.