C# Code Review Checklist: Best Practices & Tips

There are a lot of moving parts that may affect the success of your C# project. For example, what if you didn’t allocate time for managing technical debt? Better be ready to do a substantial rewrite just to untangle those dependencies. Maybe you closed your eyes to poor code quality? Well, say “hi” to unexpected bugs, security vulnerabilities, and increased maintenance costs. Was there slack on performance optimization? Then welcome to slow app response times and dissatisfied customers. All of these headaches could be, and should be, easily averted with a comprehensive code review process in place.

In this article, we’ll walk you through the essential processes of conducting an in-depth code review for a C# project. By following this Redwerk-approved checklist, you can ensure that your codebase remains clean, efficient, and future-proof.

Functionality Check

In C# applications, verifying functionality means that you’re confirming the software implements the required features correctly, and interacts as expected. This will help you catch logical errors, ensure that all features meet their specifications, and guarantee your app provides a reliable experience for end-users.

Correctness and Expected Output:

Confirm that methods and classes produce the correct output across a range of inputs, emphasizing boundary conditions and special cases
Use NUnit or xUnit for comprehensive unit testing, focusing on critical paths and functionality to automate verification processes
Implement integration tests to assess components’ interactions and data integrity within the application

Error Handling and Exception Management:

Examine the application’s approach to error handling, ensuring exceptions are caught and handled explicitly where necessary
Check for consistent use of try-catch-finally blocks, particularly in areas prone to exceptions like file I/O, network requests, and database operations
Evaluate the clarity and user-friendliness of error messages, ensuring they provide meaningful feedback without exposing sensitive system details

// Robust error handling and exception management
using System;
using System.IO;


public class FileOperations
{
   public string ReadFile(string filePath)
   {
       try
       {
           if (string.IsNullOrEmpty(filePath))
               throw new ArgumentException("File path cannot be null or empty.");


           // Attempt to read file contents
           string fileContent = File.ReadAllText(filePath);
           return fileContent;
       }
       catch (FileNotFoundException ex)
       {
           // Log and return a user-friendly message
           Console.WriteLine($"[Error] File not found: {ex.Message}");
           return "Error: The specified file was not found.";
       }
       catch (UnauthorizedAccessException ex)
       {
           // Log and return a user-friendly message
           Console.WriteLine($"[Error] Access denied: {ex.Message}");
           return "Error: You do not have permission to access this file.";
       }
       catch (Exception ex)
       {
           // Catch all other exceptions to avoid application crash
           Console.WriteLine($"[Error] An unexpected error occurred: {ex.Message}");
           return "Error: An unexpected error occurred. Please try again later.";
       }
       finally
       {
           // This block can be used for cleanup operations if needed
           Console.WriteLine("File operation completed.");
       }
   }
}

APIs and External Dependencies:

Review the integration with APIs and external libraries for correctness, focusing on data handling, authentication, and error management
Verify the application correctly manages NuGet packages, keeping dependencies up to date and resolving any version conflicts
Inspect the use of platform-specific features or APIs to ensure cross-platform compatibility, particularly for applications targeting .NET Core or .NET 8/9

Concurrency and Async/Await Patterns:

Analyze the implementation of asynchronous programming patterns, ensuring the correct use of async and await for scalable I/O operations
Review the application for proper synchronization of concurrent operations, particularly when accessing shared resources to prevent race conditions
Inspect Task Parallel Library (TPL) usage for data parallelism and PLINQ for parallel queries, ensuring they’re applied effectively to enhance performance

// Using  TPL to perform parallel data processing for compute-intensive tasks 
using System;
using System.Threading.Tasks;


public class DataParallelismExample
{
   public void ProcessData(int[] data)
   {
       // Parallel loop using TPL to process data
       Parallel.For(0, data.Length, i =>
       {
           data[i] = PerformComplexOperation(data[i]);
           Console.WriteLine($"Data at index {i} processed by task {Task.CurrentId}");
       });
   }


   private int PerformComplexOperation(int input)
   {
       // Simulating a time-consuming operation
       return input * input;
   }
}


public class Program
{
   public static void Main(string[] args)
   {
       var dataParallelismExample = new DataParallelismExample();


       int[] data = new int[10];
       for (int i = 0; i < data.Length; i++) data[i] = i;


       // Using TPL to process the data in parallel
       dataParallelismExample.ProcessData(data);


       Console.WriteLine("Data processing completed.");
   }
}




// Optimizing query performance with PLINQ's parallel execution 
using System;
using System.Linq;


public class PLINQExample
{
   public void ProcessDataWithPLINQ(int[] data)
   {
       // Parallel LINQ query to process data
       var processedData = data
                           .AsParallel()
                           .Where(x => x % 2 == 0)
                           .Select(x => PerformComplexOperation(x))
                           .ToList();


       foreach (var item in processedData)
       {
           Console.WriteLine($"Processed: {item}");
       }
   }


   private int PerformComplexOperation(int input)
   {
       // Simulating a time-consuming operation
       return input * input;
   }
}


public class Program
{
   public static void Main(string[] args)
   {
       var plinqExample = new PLINQExample();


       int[] data = Enumerable.Range(1, 10).ToArray();


       // Using PLINQ to process the data in parallel
       plinqExample.ProcessDataWithPLINQ(data);


       Console.WriteLine("PLINQ data processing completed.");
   }
}

Security Practices within Functionality:

Ensure that data validation and sanitization are properly implemented to protect against injection attacks and data corruption
Review authentication and authorization mechanisms for robustness, confirming that they safeguard sensitive operations and data access
Inspect cryptographic practices for adherence to current standards, ensuring that data encryption and secure communication are correctly implemented

// Protecting data integrity with validation, sanitization, and parameterized queries
using System;
using System.Data.SqlClient;


public class UserInputHandler
{
   private string connectionString = "YourConnectionStringHere";  // Your database connection string


   // Method to add user data into the database securely
   public void AddUser(string username, string email)
   {
       // Input validation
       if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(email))
       {
           Console.WriteLine("Error: Username and email cannot be empty.");
           return;
       }


       if (!IsValidEmail(email))
       {
           Console.WriteLine("Error: Invalid email format.");
           return;
       }


       // Using parameterized queries to prevent SQL injection
       string query = "INSERT INTO Users (Username, Email) VALUES (@Username, @Email)";


       using (SqlConnection connection = new SqlConnection(connectionString))
       {
           SqlCommand command = new SqlCommand(query, connection);
           command.Parameters.AddWithValue("@Username", username);
           command.Parameters.AddWithValue("@Email", email);


           try
           {
               connection.Open();
               command.ExecuteNonQuery();
               Console.WriteLine("User added successfully.");
           }
           catch (SqlException ex)
           {
               Console.WriteLine($"Database error: {ex.Message}");
           }
       }
   }


   // Basic email validation using a regular expression
   private bool IsValidEmail(string email)
   {
       var emailRegex = new System.Text.RegularExpressions.Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$");
       return emailRegex.IsMatch(email);
   }
}


public class Program
{
   public static void Main(string[] args)
   {
       var userInputHandler = new UserInputHandler();


       // Example of validated and sanitized user input
       userInputHandler.AddUser("john_doe", "[email protected]");


       // Example of invalid user input
       userInputHandler.AddUser("", "invalid-email");
   }
}

Performance Considerations

During a code review, focusing on performance helps identify bottlenecks, inefficient algorithms, and resource-heavy operations that can slow down your app. Performance directly impacts user experience. Having a fast, responsive app meets user expectations and gives you a competitive edge.

Code Efficiency:

Examine loops and recursive methods for optimization opportunities, such as reducing unnecessary iterations and employing memoization where applicable
Review algorithm choices for data processing tasks, ensuring that the most efficient algorithms are used for sorting, searching, and other computational operations
Assess LINQ queries for performance, particularly ensuring that operations like filtering and sorting are executed as efficiently as possible

// Efficient data filtering, sorting, and limiting with LINQ
using System;
using System.Collections.Generic;
using System.Linq;


public class LINQPerformanceExample
{
   public void GetTopStudents(List students)
   {
       // Optimized LINQ query: Filter first, then sort
       var topStudents = students
           .Where(s => s.Score > 80)  // Filtering high-performing students
           .OrderByDescending(s => s.Score)  // Sorting by score in descending order
           .Take(5)  // Selecting the top 5 students
           .ToList();


       // Displaying the results
       foreach (var student in topStudents)
       {
           Console.WriteLine($"Name: {student.Name}, Score: {student.Score}");
       }
   }
}


public class Student
{
   public string Name { get; set; }
   public int Score { get; set; }
}


public class Program
{
   public static void Main(string[] args)
   {
       var students = new List
       {
           new Student { Name = "John", Score = 85 },
           new Student { Name = "Jane", Score = 92 },
           new Student { Name = "Tom", Score = 70 },
           new Student { Name = "Emily", Score = 88 },
           new Student { Name = "Michael", Score = 95 },
           new Student { Name = "Alice", Score = 78 }
       };


       var linqExample = new LINQPerformanceExample();
       linqExample.GetTopStudents(students);
   }
}

Memory Usage:

Utilize memory profiling tools, such as the .NET Memory Profiler or Visual Studio’s Diagnostic Tools, to identify memory leaks and excessive memory allocations
Review the application’s use of large objects and collections, optimizing their usage and considering alternative data structures to reduce memory footprint
Inspect the handling of IDisposable objects to ensure that unmanaged resources are properly released, preventing memory leaks

Asynchronous Programming:

Verify the correct implementation of asynchronous methods to improve responsiveness and avoid blocking I/O operations
Assess the use of async and await keywords to ensure they’re applied correctly, avoiding common pitfalls such as deadlocks and unnecessary context switches
Review task-based operations for proper completion handling, ensuring tasks are awaited or monitored to prevent unobserved task exceptions

// Optimizing file I/O performance with asynchronous programming
using System;
using System.IO;
using System.Threading.Tasks;


public class AsyncFileOperations
{
   // Asynchronous method for reading a file
   public async Task ReadFileAsync(string filePath)
   {
       try
       {
           using (StreamReader reader = new StreamReader(filePath))
           {
               // Asynchronously read the file content
               string content = await reader.ReadToEndAsync();
               return content;
           }
       }
       catch (FileNotFoundException ex)
       {
           Console.WriteLine($"File not found: {ex.Message}");
           return "Error: File not found.";
       }
       catch (IOException ex)
       {
           Console.WriteLine($"I/O error: {ex.Message}");
           return "Error: Unable to read the file.";
       }
   }


   // Asynchronous method for writing to a file
   public async Task WriteFileAsync(string filePath, string content)
   {
       try
       {
           using (StreamWriter writer = new StreamWriter(filePath))
           {
               // Asynchronously write content to the file
               await writer.WriteAsync(content);
               Console.WriteLine("File written successfully.");
           }
       }
       catch (UnauthorizedAccessException ex)
       {
           Console.WriteLine($"Access denied: {ex.Message}");
       }
       catch (IOException ex)
       {
           Console.WriteLine($"I/O error: {ex.Message}");
       }
   }
}


public class Program
{
   public static async Task Main(string[] args)
   {
       var fileOps = new AsyncFileOperations();


       string filePath = "example.txt";
       string contentToWrite = "This is an example of async file writing and reading.";


       // Writing to the file asynchronously
       await fileOps.WriteFileAsync(filePath, contentToWrite);


       // Reading from the file asynchronously
       string fileContent = await fileOps.ReadFileAsync(filePath);
       Console.WriteLine("File content: " + fileContent);
   }
}

Database Interactions:

Analyze database queries for efficiency, using query profiling tools to identify slow-running queries and optimize them
Review the use of Entity Framework or other ORMs for potential N+1 query issues and lazy loading pitfalls, and ensure eager loading is used judiciously
Inspect connection management to ensure database connections are properly pooled and released, minimizing overhead and resource contention

Caching Strategies:

Evaluate the application’s caching strategy to ensure it effectively reduces redundant operations and database queries, thereby enhancing performance
Review the implementation of in-memory caching or distributed caching mechanisms, ensuring cache invalidation and expiration policies are appropriately configured
Inspect the use of caching for frequently accessed data, such as user sessions, configuration settings, or frequently queried database results

Network Efficiency:

Review service calls and data transfers over the network for optimization, ensuring that data is compressed and minimized to reduce latency
Evaluate the use of efficient communication protocols (e.g., gRPC, HTTP/2) for inter-service communication to enhance performance
Assess the implementation of data pagination or chunking in web APIs to optimize data retrieval and reduce payload sizes

Scalability

Examining scalability allows you to assess whether the app’s architecture and codebase can handle future growth in users, data, and features. Our scalability checklist focuses on strategies for horizontal (adding instances) and vertical scaling (upgrading resources).

Application Architecture:

Review the application’s architecture for modularity and decomposability, facilitating the ability to scale components independently
Assess the use of microservices or service-oriented architecture (SOA) where appropriate, to promote scalability and ease of deployment
Evaluate the implementation of APIs and services for statelessness, ensuring they do not store user session data locally and can scale without session affinity issues

Load Distribution and Management:

Inspect the application’s load-balancing strategy, ensuring that it effectively distributes requests across instances to maximize resource utilization and minimize bottlenecks
Review the implementation of rate limiting and throttling mechanisms to manage and control the load on the system, preventing overuse by individual users or services
Analyze the use of queueing systems (e.g., RabbitMQ, Azure Service Bus) to manage and distribute workloads evenly, especially for asynchronous tasks or background processing

Database Scalability:

Evaluate the database schema and indexing strategy for optimization, ensuring quick access to data under heavy loads
Review database usage for read-write distribution, considering the implementation of read replicas to scale read operations independently of writes
Assess the use of sharding or partitioning to distribute data across multiple databases or tables, reducing load on any single data store

Performance and Scalability Testing:

Implement load testing and scalability testing practices to identify the application’s behavior under simulated high-load scenarios, identifying bottlenecks and limits
Use profiling tools and application performance monitoring (APM) solutions to continuously monitor performance and scalability metrics, enabling proactive scaling and optimization
Review historical performance data and scalability test results to plan for future scaling needs and infrastructure improvements

Resource Optimization:

Inspect the code and resources for optimization, ensuring efficient use of CPU, memory, and network resources to allow for scaling
Evaluate the use of containerization (e.g., Docker, Kubernetes) for deploying and managing application instances, facilitating easy scaling and resource allocation
Review the application’s use of cloud services and resources, taking advantage of auto-scaling features and elastic resources to dynamically adjust to varying loads

Maintainability

A maintainable codebase reduces the cost and effort required for future development, bug fixes, and feature additions. A maintainability check helps identify areas where the code can be simplified, clarified, or better organized, leading to a more efficient development process and a more robust application.

Code Readability and Standards:

Ensure the code adheres to C# coding conventions and best practices, enhancing readability and consistency across the codebase
Implement a style guide and enforce it through tools like StyleCop or Roslyn analyzers, automating adherence to coding standards
Organize code logically, grouping related functionality together and using clear, descriptive names for classes, methods, and variables

Modular Design and Decoupling:

Design the application with modularity in mind, structuring it into independent, interchangeable modules that can be updated without wide-ranging impacts
Employ principles such as SOLID to promote a decoupled architecture, facilitating easier maintenance and extension of the codebase
Utilize interfaces and abstract classes to define contracts for modules, enhancing testability, and reducing tight coupling between components

// Violates SRP: Handles both user authentication and logging
public class UserService
{
    public void AuthenticateUser(string username, string password) { /*...*/ }
    public void LogActivity(string activity) { /*...*/ }
}

// Adheres to SRP
public class AuthenticationService
{
    public void AuthenticateUser(string username, string password) { /*...*/ }
}

public class LoggingService
{
    public void LogActivity(string activity) { /*...*/ }
}

Automated Testing and Continuous Integration:

Develop a robust suite of automated tests, including unit tests, integration tests, and end-to-end tests, to safeguard against regressions and facilitate refactoring
Integrate continuous integration (CI) pipelines that automatically build, test, and report the status of the codebase upon each commit, reinforcing code quality and maintainability
Encourage test-driven development (TDD) practices, where tests are written before code, to ensure high test coverage and code that is designed to be testable

Refactoring and Technical Debt:

Allocate time for regular refactoring sessions to improve code quality and address technical debt, prioritizing areas that are frequently modified or have proven problematic
Identify and document technical debt, including “TODO” or “FIXME” comments in the code, and track these items in a project management tool for visibility and prioritization
Foster a culture where addressing technical debt is valued as highly as adding new features, ensuring long-term health and maintainability of the codebase

// Eliminate duplicate code by abstracting common functionality
// Duplicate code
public void SendEmail(string to, string subject, string body) { /*...*/ }
public void SendNotification(string to, string message) { /*...*/ }

// Refactored
public void SendMessage(string to, string subject, string body) { /*...*/ }

Dependency Management

Examining dependencies helps identify outdated or vulnerable packages that could pose security risks or cause conflicts. It also involves checking for unnecessary dependencies that bloat your app and complicate the build process. Effective dependency management reduces the likelihood of runtime errors and simplifies future updates or migrations.

Dependency Review and Management:

Utilize NuGet for dependency management, specifying explicit versions to avoid inadvertently updating to incompatible versions
Periodically review the list of project dependencies to identify and remove unused or redundant libraries, minimizing the application’s footprint and complexity
Employ tools like NuGet Package Manager or .NET CLI to keep dependencies up to date, balancing the latest features and fixes with stability and compatibility

Security and Vulnerability Scanning:

Implement automated tools to scan dependencies for known security vulnerabilities, using services like OWASP Dependency Check or Snyk, and prioritize updating vulnerable packages
Review open-source dependencies for active maintenance and community support, preferring libraries with a strong security track record and timely updates for vulnerabilities
Incorporate security scanning into the CI/CD pipeline, ensuring dependencies are vetted for vulnerabilities before deployment

Handling Transitive Dependencies:

Understand the transitive dependency graph of your project using tools that visualize package dependencies to identify potential conflicts or unnecessary inclusions
Manage transitive dependencies by explicitly defining versions of indirect dependencies in your project file if they cause version conflicts or known issues
Monitor the impact of transitive dependencies on the project’s overall security posture and performance, adjusting direct dependencies as needed to mitigate risks

Versioning and Compatibility:

Adhere to semantic versioning principles when updating dependencies to anticipate potential breaking changes and ensure compatibility
Test thoroughly after updating dependencies to verify that changes do not adversely affect application functionality or performance
Document specific reasons for pinning dependencies to certain versions, including compatibility issues or known bugs, to inform future updates

Isolation and Modularization:

Consider the use of .NET assemblies or .NET Core global tools for isolating dependencies, reducing the risk of version conflicts across different parts of the application, or between different applications
Leverage conditional compilation symbols to handle code that must work with multiple versions of a dependency, providing flexibility and backward compatibility
Explore architectural patterns like microservices to isolate dependencies within service boundaries, minimizing the impact of updates or conflicts on the entire application

Code Organization

Good organization makes codebases easier to navigate, understand, and modify. It also fosters collaboration by providing a shared framework. Focusing on code organization enhances the overall quality of the software and contributes to a more efficient, productive development process.

Logical Structure and Namespacing:

Structure the project into clearly defined namespaces that logically group related classes and functionalities, reflecting the application’s architecture and domain
Organize namespaces and classes in a hierarchy that mirrors the application’s modular structure or feature breakdown, facilitating quick location of code
Name namespaces, classes, and methods clearly and descriptively, adhering to C# naming conventions to convey their purpose and functionality at a glance

Modularity and Separation of Concerns:

Design the application to be modular, with distinct components or services handling specific pieces of functionality, enabling independent development and testing
Apply the Separation of Concerns principle throughout the codebase, ensuring that each class or method has a single responsibility and minimal dependencies on other parts of the code
Utilize interfaces and dependency injection to decouple components, improving modularity and facilitating unit testing

Code Reusability and DRY Principle:

Identify common functionalities or patterns within the codebase and abstract them into reusable methods or classes, reducing duplication and fostering consistency
Adhere to the DRY (Don’t Repeat Yourself) principle to minimize redundant code, making the application easier to maintain and update
Evaluate the potential for creating shared libraries or packages for code that can be reused across projects or modules

Comments and Documentation:

Use XML comments to document public APIs, providing clear descriptions of methods, parameters, return values, and exceptions, which can be leveraged by IDEs and documentation generators
Include concise and meaningful comments within the code where necessary to explain complex logic, decisions, or workarounds, enhancing code readability
Maintain up-to-date README files and in-project documentation that guide new developers through the project structure, setup, and key architectural decisions

Source Control and File Organization:

Leverage source control best practices, such as meaningful commit messages and atomic commits, to maintain a clear history of changes and facilitate collaboration
Organize the file structure of the project to reflect its logical architecture, grouping related files into directories or projects within a solution, and using solution folders to categorize projects meaningfully
Include .editorconfig files to enforce consistent coding styles and settings across different IDEs and editors used by team members

Version Control

Version control enables teams to manage changes, collaborate efficiently, and maintain continual project evolution. For C# projects, employing best practices for version control is essential to streamline development and deployment processes.

Branching Strategy:

Implement a well-defined branching strategy, such as Git Flow or feature branching, to organize work on new features, bug fixes, and releases systematically
Ensure branches are named consistently, following a naming convention that includes the type of work (feature, fix, release) and a brief descriptor of the work
Adopt short-lived feature branches to facilitate quick reviews and merges, reducing merge conflicts and integrating changes more frequently

Commit Practices:

Encourage atomic commits where each commit represents a single logical change, making the project history easier to understand and troubleshoot
Write clear and descriptive commit messages that explain the what and why of the changes, following a standardized format if adopted by the team
Utilize commit hooks or automated checks to enforce coding standards and run preliminary tests before commits are accepted

Pull Requests and Code Reviews:

Leverage pull requests (PRs) for code review, ensuring every change is examined by at least one other team member for quality, functionality, and adherence to project standards
Incorporate automated build and test checks into the PR process, using continuous integration tools to verify changes before merging
Foster a culture of constructive feedback in code reviews, focusing on improving code quality, security, and performance

Version Tagging and Releases:

Use semantic versioning for tagging releases, clearly indicating breaking changes, new features, and fixes for easy version management and dependency resolution
Automate the release process as much as possible, including version tagging, changelog generation, and package publishing, which reduces manual errors and streamlines deployments
Maintain a changelog that concisely documents major changes, enhancements, and bug fixes in each release, providing stakeholders with clear version history

Security and Access Management:

Configure access controls to protect critical branches, such as main or master and release branches, ensuring that merges are subject to review and approval processes
Secure sensitive information, such as API keys and credentials, using environment variables or secure vaults rather than including them in the version control system
Regularly review team access to the version control repository, granting permissions based on roles and responsibilities, and revoking access for members who no longer require it

Backup and Disaster Recovery:

Implement regular backups of the version control repository to safeguard against data loss from hardware failures, accidental deletions, or malicious attacks
Develop and document a disaster recovery plan that includes steps for restoring the repository and associated development environments from backups
Test the disaster recovery process periodically to ensure it is effective and that the team is prepared to execute it if necessary

Perfect Your C# Project with Redwerk

Redwerk has been providing C# development services since 2005. Our C# developers have over 15 years of hands-on experience, allowing us to deliver high-quality, efficient, and secure solutions. To give you an idea of how you could benefit by partnering with Redwerk, we’ll showcase a few successful cases from our diverse portfolio.

Code Review Services

Redwerk was hired to review a network mapping app built in C# using the Uno Platform. Our scope of work included performing reviews of the architecture, database, code quality, test coverage, and security. We provided our client with an actionable plan to enhance the app’s quality before its release. Implementing our expert recommendations led to:

A 90% increase in code maintainability: This reduced the cost of future updates
Streamlined developer onboarding: This enabled our client to launch new features faster
Enhanced data security: This protected our client from reputation damage and legal action caused by any data breaches

Refactoring and Maintenance Services

A code review is just the first step towards greatness. To see the true benefits, you’ll need to follow through with all provided recommendations. When performing a code review, Redwerk will also estimate how long it will take to refactor the code, and implement all the suggested changes. If you’re short on time or expertise, we can handle the heavy lifting and help you refactor the most critical areas of your app. You can also hire Redwerk for ongoing maintenance and support, ensuring you’re not accumulating technical debt or stretching your team too thin.

Software Development from Scratch

Our team has a solid track record of developing custom C# applications. Redwerk has led projects from initial concept to deployment and beyond. We use modern yet time-proven technologies and frameworks like .NET to build scalable, maintainable, and user-friendly solutions.

Redwerk helped Recruit Media ideate, design, develop, and deploy a LinkedIn-inspired SaaS platform. We filled it with innovative features like ML-driven keyword suggestions, built-in video recording that has a teleprompter, and content moderation. After release, the platform was quickly acquired by North America’s leader in staffing solutions.

Current is another successful product we built on the .NET framework and deployed on Azure. It’s an e-government platform for processing citizens’ requests. The solution is now adopted by over ten state & county human services agencies across the USA.

Need expert help for your C# project? Contact us today for a consultation. Our team will work with you to understand your needs and devise an appropriate solution.