Uche Ali - .NET Developer

Overview

Backend API engineer (senior-level) experienced in building modular TypeScript and .NET backend services with practical strengths in transactional data handling and decoupled eventing. The strongest proven skill is building resilient API/data logic with concrete evidence in prisma transaction patterns and EF Core tenancy/optimistic-concurrency code (see blog.service.ts, task.service.ts and TaskSync TasksService). Public code shows less evidence of production-grade infra automation, formal rate-limiting/circuit-breaker strategies and formal secret-management workflows.

Timeline

Backend Engineer (.NET) · Middle

Scalefort · Full-Time

Jan 2025 to Present 1 Year 10 Months Partially remote

Built production-grade ASP.NET Core Web APIs for internal platforms and client-facing products. Implemented Clean Architecture on .NET 8 with EF-based data access, defining service boundaries, repositories, and domain-oriented data models. Developed JWT authentication with RBAC for multi-tenant flows and collaborated with product and frontend teams to define and version stable API contracts.

ASP.NET Core

C#

Clean Architecture

PostgreSQL

MediatR

Hangfire

SignalR

Amazon CloudWatch

Docker

Git

GitHub

CI/CD

Backend Developer · Middle

Arellow Homes · Full-Time

Dec 2024 to Jan 2026 1 Year 1 Month In office

Owned backend architecture for a real estate marketplace, covering domain modeling, database schema, and deployment-ready delivery. Built geospatial and multi-criteria search using PostgreSQL with optimized indexes to reduce query latency significantly. Implemented JWT/OAuth-based RBAC, added Redis caching for high-traffic listing queries, and created stored procedures and SQL functions to keep business logic consistent.

PostgreSQL

Redis

Rest API

Backend Developer · Middle

Soundrig · Full-Time

Sep 2024 to Mar 2025 6 Months In office

Developed Node.js and TypeScript backend services for a music streaming platform. Applied Redis caching and data/schema optimizations to improve content discovery latency. Built a Telegram bot with a gamified reward system and addressed security vulnerabilities, while integrating external APIs and designing real-time content flows.

Node JS

TypeScript

Redis

Backend Developer · Middle

Genesys Tech Hub (Learnable) · Full-Time

Dec 2023 to Aug 2024 8 Months In office

Built and maintained backend services for two production web applications using Node.js and TypeScript. Worked with SQL-backed relational data models to deliver production-ready APIs. Served as Scrum Master for a cross-functional team and contributed to delivering an MVP for large-scale user usage.

Node JS

TypeScript

Rest API

SQL

Scrum

University of Nigeria Nsukka

Bachelor's Degree · Mathematics

Enugu, Nigeria

Projects

Arellow (Real Estate Marketplace)

Built backend functionality for a real estate marketplace including secure authentication and REST APIs for listings and transactions. Implemented optimized relational data models, geographic search, and listing/transaction management. Concentrated on performance and correctness for marketplace search and end-to-end transaction handling.

BookNow

Architected the backend for a mechanics booking platform, focusing on reliable matching and job acceptance workflows. Implemented geospatial mechanic matching with concurrency-safe acceptance logic and real-time mechanic/customer tracking via SignalR. Added escrow payment flow integration and deployed the system using Docker on Render.

Bookovia

Designed a fast, typo-tolerant discovery experience for service providers using Meilisearch. Implemented indexing, filtering, and relevance tuning to support quick search results. Focused on improving search quality and user experience for marketplace navigation.

Technical skills

Languages

5

TypeScript

Node JS

SQL

C#

JavaScript

Node JS

8

Bcrypt

Axios

Multer

Passport.js

Ioredis

Joi

Express

Nest.JS

C#

7

ASP.NET Core

Hangfire

MediatR

SignalR

Entity Framework Core

.NET

xUnit

DevOps

7

Rest API

Amazon CloudWatch

GitHub

Docker

Git

CI/CD

AWS

Databases

3

PostgreSQL

Redis

pgvector

Other

10

React.js

Socket.IO

Claude

Swagger

Clean Architecture

Prisma

Meilisearch

Vite

RAG

MVP

Senior Backend Developer Confidence: High API Engineer

Backend API engineer (senior-level) experienced in building modular TypeScript and .NET backend services with practical strengths in transactional data handling and decoupled eventing. The strongest proven skill is building resilient API/data logic with concrete evidence in prisma transaction patterns and EF Core tenancy/optimistic-concurrency code (see blog.service.ts, task.service.ts and TaskSync TasksService). Public code shows less evidence of production-grade infra automation, formal rate-limiting/circuit-breaker strategies and formal secret-management workflows.

API Design

6/10

How well APIs are designed

APIs are modular with consistent error classes and middleware; routes use authentication and DTO/validation patterns but formal versioning and idempotency headers are not obvious.

Evidence

AppSoluteHub/appsolute_backend/src/lib/appError.ts Arellow/arellow-Api-v2/src/middlewares/auth.middleware.ts AppSoluteHub/appsolute_backend/src/features/ai-image/ai-image.route.ts

Data Layer & Database

7/10

Working with databases

Strong use of relational DB access patterns, transactional updates, upserts and some raw SQL for aggregation; clear migration artifacts and EF Core model snapshot are present.

Evidence

AppSoluteHub/appsolute_backend/src/features/blog/services/blog.service.ts (prisma.$transaction, upsert patterns) AppSoluteHub/appsolute_backend/src/features/tasks/services/task.service.ts (getUserTaskProgressService uses prisma.$queryRaw) solowiseCV/TaskSyncApp/TaskSync.Api/Infrastructure/Data/Migrations/20260730185657_InitialCreate.cs (EF Core migration)

Scalability & Performance

4/10

Handling load and speed

Some performance-minded patterns (pagination, Promise.all, outbox decoupling) are used but there is little public evidence of systematic caching strategy, load testing, or connection-pooling tuning.

Evidence

AppSoluteHub/appsolute_backend/src/features/ai-image/ai-image.service.ts (getUserImages uses Promise.all and pagination) solowiseCV/TaskSyncApp/TaskSync.Api/Modules/Tasks/TasksService.cs (outbox message pattern for decoupling)

System Architecture

6/10

Overall system structure

Code shows deliberate modular structure and multi-tenant concerns (tenant middleware, correlation ids, outbox/audit); modular monolith and service boundaries are reasonable though full microservice contracts and deployment topology are not shown.

Evidence

solowiseCV/TaskSyncApp/TaskSync.Api/Infrastructure/Middleware/CorrelationIdMiddleware.cs solowiseCV/TaskSyncApp/TaskSync.Api/Infrastructure/Middleware/TenantMiddleware.cs solowiseCV/TaskSyncApp/TaskSync.Api/Modules/Tasks/TasksService.cs (bulk update and outbox)

Security & Auth

5/10

Protecting data and access

Authentication and tenant checks are applied at boundaries, ownership checks exist (e.g., AI images); input validation appears across modules, but advanced security controls (token revocation, secret management policies) are not visible in code snippets.

Evidence

Arellow/arellow-Api-v2/src/middlewares/auth.middleware.ts AppSoluteHub/appsolute_backend/src/features/ai-image/ai-image.service.ts (ownership verification in getImageById/update/delete) AppSoluteHub/appsolute_backend/src/lib/appError.ts (centralized error types)

Reliability & Observability

6/10

Stability and monitoring

Good reliability patterns: structured AppError classes, error middleware and logging, AI-call retries and cleanup in generators, audit events and outbox for observability and eventual delivery.

Evidence

AppSoluteHub/appsolute_backend/src/lib/appError.ts and Arellow/arellow-Api-v2/src/middlewares/errors.middleware.ts AppSoluteHub/appsolute_backend/src/features/quiz/service.ts (AI generation with retry and error handling) solowiseCV/TaskSyncApp/TaskSync.Api/Modules/Tasks/TasksService.cs (audit events + outbox messages)

Verified artifacts

iyanuBoii/NFT-Scavenger-Hunt-Game· ★ 32 VolunChain/VolunChain-Backend· ★ 8 StarShopCr/StarShop-Backend· ★ 7 iyanuBoii/scavenger-hunt-backend· ★ 5

Expertise

Node.js· Middle

Backend AI & LLM· Middle

Microservices & API Architecture· Senior

Industries

Artificial Intelligence· Middle

Commerce· Middle

Government· Middle

Technologies

Rest API· since 2023

.NET

Bcrypt

Joi

Multer

ASP.NET Core· since 2025

Passport.js

Ioredis

Recommendations

Develop REST APIs and feature services (Node.js + Prisma) requiring transactional consistency and complex join/cleanup logic, e.g., content or e-commerce backends.
Build multi-tenant SaaS modules and operationally-critical features using ASP.NET Core with EF Core, focusing on tenancy isolation, optimistic concurrency and outbox/event delivery.
Implement AI/LLM-backed features (prompt pipelines, evaluation, image generation) where validation, retry and safe-content handling are required.
Create background workers and reliable integrations (outbox, audit, Cloudinary/replicate integrations) and end-to-end tests for those flows.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

arellow-Api-v2 appsolute_backend TaskSyncApp

Senior QA Engineer Confidence: Medium SDET

Senior SDET and backend engineer specializing in robust integration testing and multi-tenant API correctness. The strongest proven skill is building repeatable end-to-end integration tests and seeded test hosts as shown by AdditionalIntegrationTests.cs and the AdditionalTestFactory that seeds an in-memory database and verifies cross-tenant and concurrency failure modes. Public code does not demonstrate load/performance testing, CI workflow test matrices, or formal contract testing artifacts like Pact or Schemathesis.

Test Automation Frameworks

7/10

Building automated tests

Solid test automation infrastructure and fixtures for integration tests including a seeded in-memory database, WebApplicationFactory test host, and deterministic seeding for isolation and repeatability.

Evidence

solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: AdditionalTestFactory.ConfigureWebHost uses UseInMemoryDatabase and custom seeding solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: GetSeededClient and SeedAsync implement controlled seeding and a semaphore to avoid race conditions

Test Coverage & Strategy

8/10

What and how to test

Test coverage focuses on risky and negative paths with explicit assertions for failure modes (cross-tenant access, optimistic concurrency conflicts, permission denials) rather than only happy paths.

Evidence

solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: AttachmentDownload_CrossTenant_ReturnsNotFound validates cross-tenant access is rejected (404) solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: TaskUpdate_StaleRowVersion_ReturnsConflict implements optimistic concurrency negative test asserting 409

API & Integration Testing

8/10

Testing how parts work together

Strong API and integration testing practices: end-to-end HTTP tests against an in-memory test host, seeded domain data, auth token retrieval and assertion of API responses including audit/outbox behaviors.

Evidence

solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: EndToEnd_CreateTaskCommentAudit_HappyPath creates a task, adds comment and verifies audit entries via API solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: GetAuthToken posts to /api/auth/login and uses returned token for subsequent API calls

Performance & Load Testing

Testing speed under load

Not evidenced in public code

Bug Reporting & Analysis

4/10

Finding and describing bugs

Evidence of diagnosing and encoding reproducible failure cases in tests exists, but there are no publicly visible formal bug reports, postmortems, or mutation testing results.

Evidence

solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: Tests include comments documenting the intent and root cause checks (cross-tenant, concurrency) solowiseCV/TaskSyncApp/TaskSync.Tests/AdditionalIntegrationTests.cs: BulkStatusUpdate_OnlyAffectsSameTenant documents expected behavior and verifies skipped IDs

CI Test Integration

Running tests automatically

Not evidenced in public code

Expertise

SDET & Test Engineering· Senior

API Testing & Contract Validation· Middle

Industries

Government· Senior

Real Estate· Middle

Technologies

JavaScript

SQL· since 2023 · Middle

C#· since 2025 · Senior

Swagger

CI/CD· since 2025

Git· since 2025

AWS

Docker· since 2025

Entity Framework Core

SignalR· since 2025

MediatR· since 2025

xUnit

Hangfire· since 2025

GitHub· since 2025

Amazon CloudWatch· since 2025

Recommendations

Lead building end-to-end integration test harnesses and test factories for multi-tenant APIs, focusing on negative paths and concurrency.
Implement CI pipelines that run the seeded integration suites, collect artifacts, and add per-test quarantines or targeted retries for flaky tests.
Design API contract tests and schema validations (Pact or Schemathesis) and add performance smoke tests (k6/locust) to cover SLOs and ramp/threshold behavior.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

arellow-Api-v2 appsolute_backend TaskSyncApp

Middle Frontend Developer Confidence: Medium Fullstack

Fullstack engineer (senior-level baseline, 3.5) focusing on backend APIs and integrations with a proven strength in AI and external-service integration. The strongest proven skill is building reliable backend features with AI integration and persistence, demonstrated by quiz.service.ts (Replicate AI validation, robust parsing, transactions) and ai-image.service.ts (Replicate + Cloudinary flow, file streaming and cleanup). There is limited evidence of a dedicated frontend component library, advanced a11y work, or measured frontend performance instrumentation in public code.

UI Component Architecture

2/10

How interface parts are built

Limited frontend component architecture evidence; there is a small React app and CSS with tokens and utilities but no clear custom component library, composition patterns, or advanced custom hooks for UI state.

Evidence

solowiseCV/mingle/src/services/websocket.js: connectToRoom WebSocket helper used by UI solowiseCV/mingle/src/index.css: design tokens and utility classes used by UI pages

Responsive & Cross-browser

3/10

Works on all screens and browsers

Responsive layout and tokenized CSS exist (fluid grids, utility classes) but there is no evidence of advanced cross-browser feature detection, RTL/i18n support, or container queries.

Evidence

solowiseCV/mingle/src/index.css: CSS tokens, grid (repeat(auto-fill, minmax(...))) and responsive utilities solowiseCV/mingle/src/pages/Rooms.css: grid-based responsive room cards and loading skeletons

Performance Optimization

4/10

Speed of the interface

Concrete backend performance-conscious code (timeouts, fail-fast, parallel IO, Prisma transactions) and some parallelization; no formal before/after measurements or bundle-analyzer artifacts for frontend.

Evidence

tsbEpay/tsbEpay-MfiatAgentPayout/src/services/currencyService.ts: axios timeouts, error handling, rate-limit handling and efficient cross-rate calculation AppSoluteHub/appsolute_backend/src/features/ai-image/ai-image.service.ts: parallel Cloudinary uploads and Promise.all usage; streaming downloads to temp files and cleanup AppSoluteHub/appsolute_backend/src/features/tasks/services/task.service.ts: careful Prisma queries and $queryRaw for aggregated counts

Accessibility & Semantics

1/10

Usable for everyone

Minimal explicit accessibility or semantics work is present; CSS contains visual styles and states but there is no evidence of ARIA handling, focus management, or a11y testing in the human-authored code reviewed.

Evidence

solowiseCV/mingle/src/index.css: UI tokens and visual classes (no explicit a11y patterns) solowiseCV/mingle/src/pages/Login.css: visual design and layout without visible a11y affordances

State Management & Data Flow

4/10

Managing data in the app

Server-state discipline is visible: Prisma transactions, session handling and refresh token flows, defensive checks, duplicate handling and race-avoidance in quiz flows; client-side state management is minimal.

Evidence

tsbEpay/tsbEpay-MfiatAgentPayout/src/services/agent/authService.ts: session creation, token signing, refresh token verification and session lifecycle AppSoluteHub/appsolute_backend/src/features/quiz/service.ts: duplicate-answer checks, attempts counting, AI validation, and transactional score updates AppSoluteHub/appsolute_backend/src/features/blog/services/blog.service.ts: transactional updates and careful join-table recreation

UX & Visual Polish

4/10

Look and feel quality

Good visual polish and UX scaffolding in CSS (skeletons, loading/empty states) and conversational messages from backend AI flows, but UX edge-state strategies and undo patterns are mostly backend-driven and not fully complete on the client.

Evidence

solowiseCV/mingle/src/index.css: skeleton, spinner, loading and modal styles solowiseCV/mingle/src/pages/Chat.css: explicit loading and empty states AppSoluteHub/appsolute_backend/src/features/quiz/service.ts: NLPHelper.generateConversationalMessage for friendly UX messages and range/invalid handling

Expertise

React· Middle

Frontend AI Integration· Middle

Frontend Architecture & Build Tools· Middle

Industries

Financial Services· Middle

Technologies

TypeScript· since 2023 · Senior

Node JS· since 2023 · Senior

Express

Socket.IO

Prisma

React.js

Vite

Axios

Recommendations

Lead development of AI-driven backend features and integrations (image generation, answer validation, model orchestration) where Replicate/3rd-party models and safe parsing are required.
Design and implement server-side APIs with Prisma and transactional boundaries for multi-table domain logic (content, tasks, quizzes, payments).
Build real-time features and websocket-backed UIs, pairing the backend realtime logic with a focused React component layer and state handling.
Harden production concerns: add end-to-end a11y checks, structured frontend component architecture, and CI-based performance budgets and bundle analysis

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

appsolute_backend tsbEpay-MfiatAgentPayout mingle

Job preferences

Work permits: Nigeria