Stack Developer .Net Core

Sandeep Sagar Varkoor

Sr .Net Full Stack Developer

+1-980-***-**** *********************@*****.*** Linkedin

Professional Summary:

• Senior .NET Full Stack Developer with 10+ years of experience architecting and delivering enterprise-scale applications across banking, healthcare, insurance, compliance, and retail domains using modern Microsoft, JavaScript, and cloud technologies.

• Proficient in .NET Core (2.2–6) and C# (5.0–10.0) for building high-performance RESTful and GraphQL (HotChocolate) APIs with asynchronous patterns, layered architecture, and secure data processing.

• Applied SOLID principles and implemented key design patterns including Repository, Unit of Work, Factory, Singleton, and Dependency Injection, enabling scalable, testable, and loosely coupled systems.

• Developed solutions using MVC, 3-tier, and microservices architectures, separating presentation, business, and data layers for long-term maintainability and flexibility.

• Created dynamic SPAs using Angular (10–15), React 16.7, AngularJS, and Blazor Server, with advanced state management, dynamic routing, role-based rendering, and offline workflows.

• Delivered ADA/WCAG 2.1 compliant UI components using Angular Material, Bootstrap (3.3 to 5), HTML5, and CSS3, supporting accessibility features like keyboard traps, ARIA roles, and high-contrast themes.

• Built enterprise-grade form systems with Angular Reactive Forms, Formik + Yup, and custom validators, supporting nested groups, conditional visibility, and digital signature handling.

• Ensured robust communication using Angular’s HttpClientModule, interceptors, and retry logic with JWT-based authentication, centralized error handling, and secure token exchange protocols.

• Secured APIs using JWT, OAuth 2.0 (Authorization Code Flow), IP whitelisting, Role-Based Access Control (RBAC), and middleware-based authorization.

• Developed real-time modules using SignalR and GraphQL Subscriptions, enabling instant inspector assignments, compliance updates, and live dashboard synchronization.

• Modeled and optimized relational schemas using SQL Server (2012–2019) and Azure SQL, with partitioning, indexed views, foreign key constraints, and computed columns for performance.

• Authored complex T-SQL stored procedures, user-defined functions, and DML triggers for scheduling, risk scoring, DTI calculation, refill tracking, and audit trails.

• Used Entity Framework Core (2.2–6) and EF 6.1 for ORM with LINQ, transaction scopes, eager/lazy loading, and seamless database migrations.

• Built and deployed offline-capable mobile applications using .NET MAUI, supporting local entry, inspection image capture, and secure synchronization to backend APIs.

• Hosted and scaled services using Azure App Services, Red Hat OpenShift, AWS EC2, Docker, Kubernetes, and Helm, supporting both Windows and Linux-based containers.

• Integrated Salesforce CRM using custom Apex REST endpoints, synchronizing compliance records, facility contacts, and scheduling logic with internal .NET applications.

• Developed CI/CD pipelines using Azure DevOps, GitHub Actions, and AWS CodePipeline, incorporating PowerShell scripting, build validations, and deployment slot strategies.

• Automated test environments and artifact deployments across QA, UAT, and Prod using YAML, classic pipelines, and release gates configured through Azure DevOps and TFS Build Server.

• Designed asynchronous message-based workflows using Azure Service Bus, Amazon SQS, and MSMQ, handling distributed task orchestration, dead-letter processing, and retry logic.

• Authored and consumed APIs with Swagger/OpenAPI, Swashbuckle, and schema validation tooling, enabling independent development, QA automation, and self-documenting interfaces.

• Secured document storage using Azure Blob Storage and Amazon S3, managing SAS tokens, access tiers, encryption policies, and lifecycle rules for sensitive files.

• Integrated legacy C++ logic into .NET apps using P/Invoke, managing native interop with performance tuning, memory safety, and backward compatibility.

• Performed comprehensive unit testing using xUnit, NUnit, MSTest, with mocking frameworks like Moq and TestServer to test services, controllers, and middleware.

• Built robust frontend testing pipelines using Cypress, Karma, Jasmine, Cucumber (Gherkin), Jest, and Enzyme to validate form behaviors, guards, and UI logic.

• Proven ability to build secure, scalable platforms for transaction-heavy systems aligned with eCommerce patterns, including secure account creation, identity and access management, search integration, checkout-equivalent flows, and real-time order/inspection lifecycle management.

• Managed Git-based version control using GitHub, Azure Repos, and Bitbucket, following GitFlow branching, pull request templates, code reviews, and tagging strategies.

• Developed and validated lightweight, cross-platform JSON payloads using System.Text.Json, custom converters, and schema definition for minimal network footprint.

• Tracked Agile and Waterfall progress using JIRA, Azure Boards, and Confluence, maintaining sprint metrics, documentation, burndown charts, and project-wide traceability.

Technical Skills:

Cloud Environments

Microsoft Azure (App Services, Logic Apps, Data Factory, Blob Storage, Queue Storage, Key Vault, Azure Kubernetes Service, Azure DevOps, Azure SQL, Application Insights), AWS (EC2, S3, RDS, Lambda, ECS, SQS, CodePipeline, API Gateway), Red Hat OpenShift

Languages

.NET (ASP.NET, C#.NET, .NET Core 2.2–7), JavaScript, TypeScript (up to 4.8), VB.NET, PL/SQL, T-SQL, HTML5, CSS3, SQL, C++, JSON, XML

Methodologies

Agile (Scrum, Kanban), Waterfall, CI/CD, Domain-Driven Design (DDD), DevOps

Web Technologies

HTML5, CSS3, Bootstrap 3.3/4.1/5, JavaScript (ES5/6+), jQuery, AJAX, Angular (2–15), React.js (15/16.7), Redux, AngularJS, Blazor (Server/WebAssembly), Storybook

.NET Technologies

C#, ASP.NET MVC, ASP.NET Core Web API, .NET Core (2.2–7), WinForms, WPF, Blazor, WCF, SOAP, LINQ, .NET MAUI (POC), SignalR

Databases

SQL Server (2012–2019), PostgreSQL, MySQL, Cosmos DB, MongoDB Atlas,

Azure SQL

ORM

Entity Framework Core (2.2–6), Entity Framework 6.1, LINQ to SQL, NHibernate,

EF Code First, EF Migrations

Version Control Tools

Git, Azure Repos, GitHub, Bitbucket

Testing Tools

xUnit, NUnit, MSTest, Jasmine, Karma, Moq, Cypress, Selenium, Postman,

Swagger/OpenAPI, Jest, Enzyme, TestServer, Cucumber (Gherkin)

Bug Tracking

Azure Boards, JIRA, Bugzilla

Containerization/Orchestration

Docker, Kubernetes (AKS/ECS), Docker Compose, Helm

Professional Experience:

Client: State of CA, SFO, CA. Feb 2023 to Present

Role: Sr .Net Full Stack Developer

Responsibilities:

• Followed Agile methodology, conducting bi-weekly sprints with sprint planning, backlog grooming, retrospectives, and stakeholder demos to deliver features for scheduling automation, compliance scoring, and health inspection workflows.

• Utilized .NET 6 and C# 10.0 to build scalable and secure backend services incorporating async programming, dependency injection, and strong typing to handle inspection scheduling logic, inspector assignments, and violation escalation rules.

• Used Razor Pages for lightweight admin tools and MVC for controller-based APIs and Angular integration.

• Followed SOLID principles and implemented Repository, Unit of Work, Factory, Singleton, and Dependency Injection design patterns to promote maintainability, separation of concerns, and automated testability across business and data layers.

• Architected the system using MVC pattern, integrating Angular 15 frontend with ASP.NET Core Web API and GraphQL (HotChocolate) to deliver REST and flexible query-based APIs for inspection status tracking, facility metadata, and regulation lookup.

• Developed modular RESTful and GraphQL APIs, implementing attribute routing, pagination, filtering, and error handling for endpoints used in inspection dashboards, audit logs, and rule-based scheduling engines.

• Employed Entity Framework Core 6 for ORM, utilizing LINQ queries, repository abstraction, transaction scopes, and EF Migrations for seamless schema evolution and unit testing compatibility.

• Structured lightweight and flexible frontend-backend communication using JSON and GraphQL payloads, enabling optimized network performance for tablet-based field operations.

• Built responsive, dynamic user interfaces with Angular 15 and Angular Material, designing ADA-compliant and WCAG 2.1 accessible components such as wizard forms, step-by-step workflows, data tables, and modal dialogs with complete keyboard navigation support.

• Applied CSS3 and Bootstrap 5 for visually rich and responsive layouts, incorporating custom styling for health department branding and adaptive inspection card views across desktop, mobile, and tablet screens.

• Managed HTTP communication using Angular’s HttpClientModule, implementing JWT token interceptors, retry logic for transient failures, and centralized global error handlers to ensure robustness in API communication.

• Modeled relational schema in SQL Server 2019 and Azure SQL Database, creating partitioned tables, indexed views, and foreign key constraints to store inspection records, user data, violation codes, and calendar metadata.

• Wrote modular and reusable T-SQL stored procedures for calculating risk scores, allocating inspectors, checking time conflicts, and managing facility violation history.

• Created scalar-valued functions and DML triggers to handle defaulting logic, audit logs, and enforcement of business constraints on status updates and SLA timelines.

• Integrated Azure Service Bus queues and topics for decoupled, asynchronous messaging between the frontend module and backend compliance processing services, incorporating retry policies and dead-letter handling.

• Developed comprehensive unit tests for controllers, services, and data access layers using xUnit, Moq, and TestServer, achieving over 90% test coverage and ensuring regression-safe deployments.

• Built robust UI automation tests using Cypress and Cucumber (Gherkin syntax) to validate inspection lifecycle workflows, user permissions, date-based scheduling forms, and conditional UI rendering based on roles.

• Performed manual and automated API contract testing using Postman, validating authentication headers, error scenarios, and success responses, and documented the API suite using Swagger/OpenAPI.

• Deployed application containers to Azure App Services for staging and internal testing environments, while utilizing Red Hat OpenShift with Kubernetes and Helm for production-grade deployments, ensuring scalable orchestration of .NET APIs and Angular services.

• Automated CI/CD pipelines using Azure DevOps, incorporating PowerShell scripts to manage pipeline variables, cleanup post-deployment tasks, validate token expirations, and run scheduled test suites.

• CI/CD pipelines were orchestrated using Azure DevOps for both staging and production workflows, integrating with GitHub Actions and OpenShift deployment targets through Helm charts.

• Enabled secure file handling through Azure Blob Storage, using SAS tokens, container-level access policies, and lifecycle rules to manage KYC documents, inspector photos, inspection checklists, and final reports.

• Designed and implemented a proof-of-concept .NET MAUI mobile application allowing inspectors to operate in offline mode, store entries locally, and sync data back to the central system securely through API integration.

• Integrated external Salesforce CRM data using custom Apex REST endpoints, synchronizing facility contact details, compliance history, and scheduling coordination between internal and partner systems.

• Integrated Microsoft Entra ID for centralized user identity management, leveraging Azure AD B2C for role-based access control, secure token issuance, and conditional multi-factor authentication workflows.

• Enforced JWT-based authentication and RBAC (Role-Based Access Control) to manage secure access across modules, with token refresh logic and IP-based whitelisting applied through middleware policies.

• Implemented OAuth2.0 authorization flows alongside JWT for enhanced security, enabling support for delegated access via Authorization Code flow and ensuring secure integration with third-party systems and internal apps.

• Used Git and GitHub for version control, following GitFlow branching strategy with enforced pull request approvals, code reviews, and automated pre-commit checks using GitHub Actions workflows.

• Managed Agile sprints, backlogs, and sprint metrics using Azure DevOps Boards integrated with JIRA, supporting team-wide planning, sprint reviews, and burndown analysis.

• Built real-time notification modules using SignalR, enabling instant inspector assignment alerts, compliance score updates, and calendar event reminders across tabs without page reloads.

• Integrated Redis for distributed caching of inspection status lookups, user role permissions, and API token sessions, reducing latency and improving API response times by over 35%.

• Utilized Elasticsearch with Kibana for advanced search and analytics over inspection logs, compliance flags, and real-time event tracking, enhancing dashboard filtering and alert capabilities.

• Utilized Lucene-compatible search stack including Elasticsearch and Apache Solr, enabling faceted search, auto-suggestions, and filterable inspection metadata; enhanced dashboard filtering and analytics through Kibana integration.

• Monitored application health using Azure Application Insights, custom telemetry events, and log analytics to trace API response times, frontend load metrics, and data sync issues.

• Ensured ADA compliance by applying semantic HTML, high-contrast theming, keyboard traps, and tested screen-reader compatibility across critical inspection and reporting modules.

• Experimented with GraphQL subscriptions in pilot dashboards to support real-time state updates during live inspections and dynamic facility condition reporting.

• Authored comprehensive documentation using Confluence, including solution architecture diagrams, API flowcharts, and user onboarding guides for developers and QA teams.

Environment: C# 10.0, .NET 6, ASP.NET Core Web API, Angular 15, TypeScript 4.8, Angular Material 15, HTML5, CSS3, Bootstrap 5, Entity Framework Core 6, LINQ, SQL Server 2019, T-SQL, PL/SQL, JSON, JWT, Role-Based Access Control (RBAC), Azure Blob Storage, Azure Logic Apps, Azure App Services, Azure SQL Database, Azure Service Bus, Azure DevOps (Pipelines, Repos, Boards), PowerShell, Git, GitHub Actions, OAuth2.0, xUnit, Moq, TestServer, Cypress, Cucumber (Gherkin), Postman, Swagger/OpenAPI, OpenShift, Helm, Kubernetes, .NET MAUI (POC), Salesforce Apex (REST Integration), Confluence, JIRA.

Client: Citi Bank, NYC, NY. Dec 2020 to Jan 2023

Role: .Net Full Stack Developer

Responsibilities:

• Adapted Agile methodology with story grooming, sprint planning, daily stand-ups, retrospectives, and sprint reviews to iteratively deliver key features of the loan origination and approval modules, ensuring stakeholder feedback was continuously incorporated into each sprint cycle.

• Developed scalable and secure RESTful APIs using ASP.NET Core 3.1 and C# 8.0, utilizing async/await and strong typing for robust backend services supporting loan data ingestion and underwriting workflows.

• Implemented a modular MVC architecture integrating Angular 10 for user-facing modules, Blazor Server for internal dashboards, and .NET Web APIs as the data layer, promoting separation of concerns and shared logic reuse.

• Utilized Blazor Server to build responsive, real-time dashboards for compliance officers and underwriters, enabling live collaboration on high-value loan applications with conditional business rule validation.

• Designed and implemented shared service contracts, DTOs, and common model layers to ensure seamless interoperability between front-end modules and microservices, enabling future extensibility with minimal refactoring.

• Integrated internal systems with Micro Focus PPM APIs to automatically sync project status, update resource assignments, and generate audit logs required for compliance and PMO reporting.

• Applied Repository and Unit of Work patterns to create a clean, testable, and scalable data access layer, decoupled from business logic for long-term maintainability.

• Utilized Singleton pattern for configuration services such as app settings and logging, and implemented Factory pattern to generate dynamic loan workflows based on customer profiles, risk categories, and loan types.

• Established robust security mechanisms using JWT-based authentication, rate limiting, and IP whitelisting, securing sensitive APIs that handle financial and personal data in compliance with banking standards.

• Contributed to modernization of a legacy C++ rules engine, using P/Invoke to call native libraries from C#, while carefully handling memory management and performance-critical sections during refactoring.

• Employed Entity Framework Core 3.1 and LINQ for efficient data operations, managing migrations, transaction scopes, and lazy/eager loading based on usage patterns across dashboards and reports.

• Standardized communication between client and server using JSON payloads with well-defined schemas and implemented System.Text.Json for lightweight, high-performance serialization and deserialization.

• Designed responsive and interactive UIs using Angular 10, TypeScript, and Angular Material 10, with components such as multi-step forms, document uploaders, dashboards, and audit trail views.

• Created modular and reusable Reactive Form components with complex nested form groups, dynamic validations, and real-time calculation logic to enhance data quality during loan application entry.

• Applied Angular HttpClient interceptors to manage token injection, response logging, and centralized error-handling, supporting clean API interaction logic across multiple components.

• Used CSS3, Angular Material theming, Flex Layout, and media queries to ensure responsive and brand-consistent design across both internal and public-facing modules.

• Defined and implemented relational schema in Azure SQL Database, including primary/foreign key constraints, views, indexes, and complex joins optimized for underwriting logic and financial calculations.

• Wrote advanced T-SQL stored procedures to automate eligibility determination, DTI ratio calculations, and tier-based interest computation, integrating data from applicant history and third-party reports.

• Implemented AFTER INSERT and AFTER UPDATE triggers to capture application status changes and trigger workflows including document verification, email/SMS alerts, and audit logging.

• Used NLog to implement configurable, async logging across backend services with dynamic log levels and secure storage of audit trails and exception metadata.

• Employed iTextSharp for generating downloadable PDF summaries of loan approval reports, terms, and underwriting workflows, applying digital signatures and custom branding.

• Utilized Azure Service Bus for decoupled handling of asynchronous tasks such as pulling credit reports, SLA monitoring alerts, and inter-service notifications, with retry logic for transient failures.

• Configured and maintained Azure DevOps Pipelines using both classic and YAML pipelines to automate build, test, and release cycles, including deployment slot swapping and environment-specific configuration.

• Wrote extensive unit and integration tests using xUnit and Moq, covering middleware, controller, and service layers with code coverage across the backend codebase.

• Created and executed Angular component tests using Karma and Jasmine, validating forms, services, guards, and UI behaviors under multiple data and permission scenarios.

• Performed manual API testing with Postman, using mock environments and scripting to test token-based authentication, edge-case inputs, and header manipulations.

• Integrated Power BI dashboards into underwriting portals to provide real-time loan metrics such as approval rates, risk segmentation, processing delays, and compliance KPIs.

• Enabled API consumer teams to test endpoints independently by implementing Swagger (Swashbuckle) with auto-generated documentation and schema testing tools.

• Hosted APIs and Blazor apps in Azure App Services, using deployment slots, autoscaling, managed certificates, and traffic routing to enable zero-downtime deployments.

• Leveraged Azure Blob Storage for secure, scalable storage of sensitive documents including KYC, income proofs, signed agreements, with SAS token-based access controls.

• Used Git and Azure Repos with Git Flow branching strategy, including pull requests, code reviews, release tagging, and branch policies to maintain high code quality standards.

• Managed user stories, bugs, and tasks using Azure Boards, maintaining traceability from development to delivery with linked commits and automated status updates.

Environment: ASP.NET Core 3.1, C# 8.0, Angular 10, TypeScript 3.9, Blazor Server, HTML5, CSS3, Angular Material 10, Entity Framework Core 3.1, Azure SQL Database, Azure App Services, Azure Blob Storage, Azure Service Bus, Azure DevOps (Pipelines, Repos, Boards), Git, T-SQL, System.Text.Json, Swagger (Swashbuckle), Power BI, Postman, xUnit, Moq, Karma, Jasmine, Visual Studio 2019, VS Code.

Client: Verisk, Jersey City, NJ. Jan 2019 to Nov 2020

Role: .Net Application Developer

Responsibilities:

• Integrated Waterfall methodology to deliver each project phase from requirement gathering, design, coding, testing, to deployment with defined timelines, documentation, and customer sign-offs.

• Built backend logic using ASP.NET Core 2.2 and C# 7.3, enabling robust claims processing workflows, modular API design, and business logic encapsulation with strong type safety.

• Implemented Repository, Factory, and Dependency Injection patterns to promote code reusability, testability, and loosely coupled modules across the application stack.

• Designed end-to-end using MVC architecture, combining React 16.7 as the front-end with ASP.NET Core Web API to create a clean separation of concerns and smooth request/response flow.

• Developed scalable RESTful APIs using ASP.NET Core 2.2, with secure JWT-based authentication and authorization layers for claims data access.

• Designed internal PIM-style architecture for centralized management of claim-related entities, including schema governance, attribute enrichment, and integration with external reporting systems.

• Used AWS API Gateway to expose and manage REST endpoints and throttle external request traffic.

• Integrated Entity Framework Core 2.2 with LINQ for efficient data querying and domain modeling.

• Managed schema versioning and evolution using Code First Migrations, reducing deployment effort.

• Standardized payloads using JSON across APIs, ensuring platform-independent communication.

• Implemented custom JSON converters and serialization options for nested claim data formats.

• Developed a rich and interactive UI using React 16.7, TypeScript 3.2, and Redux 4.0, focusing on performance, reusability, and state consistency.

• Used wireframe and prototyping tools such as Balsamiq and Figma to visualize user journeys, form layouts, and workflow paths, streamlining collaboration with UX designers and business analysts during UI iterations.

• Built adaptive, theme-consistent screens using CSS3, Bootstrap 4.1, media queries, and flexbox grid systems to ensure cross-device compatibility.

• Implemented promise-based API interactions with Axios, including token refresh via interceptors and global error handling, and developed reusable controlled forms using Formik with Yup

• Used AWS RDS (SQL Server 2016) for relational data storage and transactional support for claims lifecycle.

• Designed complex T-SQL stored procedures and scalar functions to handle core processing like auto-approvals, user validation, and audit logging.

• Used triggers to enforce data integrity and automatically update tracking logs on insert/update.

• Used Amazon SQS to enable asynchronous communication between claims submission and automation workers.

• Set up AWS CodePipeline and AWS CodeBuild for end-to-end CI/CD of React and .NET Core services.

• Wrote comprehensive unit tests using xUnit, with mocks and fakes handled by Moq to validate repository, service, and controller layers.

• Enabled integration testing for API endpoints and DB interactions with test runners and scripts.

• Validated UI components using Jest and Enzyme, covering event simulation, DOM snapshots, and form workflows.

• Performed API and functional testing using Postman and defined test collections.

• Used Swagger/OpenAPI for contract validation and auto-generating documentation for QA and UAT.

• Deployed microservices and UI apps using AWS EC2, S3, and API Gateway, along with RDS for backend data.

• Managed code using Git with Bitbucket, applying Git Flow branching strategies for feature and release management.

• Tracked development tasks, bugs, and enhancements using JIRA, aligned with defined milestones in the waterfall lifecycle.

• Used Confluence to maintain technical documentation, project notes, and change history for stakeholders.

Environment: ASP.NET Core 2.2, C# 7.3, MVC, React 16.7, TypeScript 3.2, Redux 4.0, HTML5, CSS3, Bootstrap 4.1, Axios, Formik, Yup, Entity Framework Core 2.2, LINQ, SQL Server 2016, T-SQL, AWS EC2, S3, RDS, API Gateway, SQS, AWS CodePipeline, AWS CodeBuild, JSON, Swagger/OpenAPI, xUnit, Moq, Jest, Enzyme, Postman, Git, Bitbucket, JIRA, Confluence, Visual Studio, VS Code

Client: Rite Aid, Minnesota. Feb 2017 to Dec 2018

Role: Software Developer.

Responsibilities:

• Followed the Waterfall SDLC model, executing structured phases from business requirements through design, development, testing, deployment, and sign-off for prescription processing modules.

• Developed backend workflows using ASP.NET MVC 5 and C# 6.0 features such as expression-bodied methods, string interpolation, and auto-property initializers to streamline prescription request logic.

• Applied Repository and Factory design patterns to build testable, maintainable, and loosely coupled components across modules like refill tracking and provider lookup.

• Implemented a 3-tier architecture (Presentation – Business – Data Access) that cleanly separated logic across AngularJs, Web API 2, and SQL Server-based services.

• Designed secure, stateless RESTful services using ASP.NET Web API 2, enabling seamless interaction between pharmacy frontends and backend services for real-time prescription validation.

• Consumed and exposed all API payloads in JSON format, and integrated XML (NCPDP-compliant) for standardized prescription data exchange across external providers and health systems.

• Integrated OpenText ExStream for generating dynamic prescription letters, refill reminders, and EOBs, using template-driven logic and data mapping modules to meet pharmacy communication compliance standards.

• Utilized Entity Framework 6.1 with LINQ and code-first migrations to interact with SQL Server 2012, maintaining a normalized schema for patients, prescriptions, providers, and pharmacists.

• Developed dynamic and reusable UI components using AngularJS and TypeScript, including form-based views for dosage entry, patient details, and refill logs.

• Styled responsive pages with Bootstrap 3.3 and CSS3, ensuring compatibility with pharmacy desktops and tablets through media queries and flexible grid layouts.

• Maintained and refactored legacy modules written in VB.NET, migrating key workflows to C# 6.0 and ASP.NET MVC 5, ensuring business continuity during modernization of the prescription processing system.

• Managed API calls using AngularJS $http service with token-based authorization, response interceptors, and standardized error handling across all modules.

• Built form validation logic within AngularJS controllers and directives, ensuring accurate entry of prescription details using required field constraints, pattern matching, and conditional validations.

• Modeled SQL Server 2012 schema with foreign keys, constraints, and indexes to support fast lookups for patients, medications, and historical prescription data.

• Created T-SQL stored procedures for calculating dosage ranges, patient eligibility, and refill windows, ensuring logic was centralized and reusable across modules.

• Developed user-defined functions (UDFs) to encapsulate calculation logic for provider ratings, prescription durations, and medication interactions.

• Implemented AFTER INSERT/UPDATE triggers to log audit trails and enforce data consistency on critical tables like prescriptions, refills, and provider responses.

• Used MSMQ (Microsoft Message Queuing) for...

Contact this candidate