Comprehensive comparison for Backend technology in Fintech applications

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.ComponentModel.DataAnnotations;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;

namespace FintechBackend.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class TransactionsController : ControllerBase
    {
        private readonly ITransactionService _transactionService;
        private readonly ILogger<TransactionsController> _logger;

        public TransactionsController(ITransactionService transactionService, ILogger<TransactionsController> logger)
        {
            _transactionService = transactionService;
            _logger = logger;
        }

        [HttpPost("transfer")]
        public async Task<IActionResult> CreateTransfer([FromBody] TransferRequest request)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    return BadRequest(ModelState);
                }

                var result = await _transactionService.ProcessTransferAsync(request);
                
                _logger.LogInformation("Transfer completed successfully. TransactionId: {TransactionId}", result.TransactionId);
                
                return Ok(new TransferResponse
                {
                    TransactionId = result.TransactionId,
                    Status = "Completed",
                    Timestamp = DateTime.UtcNow
                });
            }
            catch (InsufficientFundsException ex)
            {
                _logger.LogWarning(ex, "Insufficient funds for transfer. AccountId: {AccountId}", request.FromAccountId);
                return BadRequest(new { error = "Insufficient funds", details = ex.Message });
            }
            catch (AccountNotFoundException ex)
            {
                _logger.LogWarning(ex, "Account not found. AccountId: {AccountId}", ex.AccountId);
                return NotFound(new { error = "Account not found", accountId = ex.AccountId });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Unexpected error during transfer processing");
                return StatusCode(500, new { error = "An error occurred processing your request" });
            }
        }
    }

    public class TransferRequest
    {
        [Required]
        public string FromAccountId { get; set; }
        
        [Required]
        public string ToAccountId { get; set; }
        
        [Required]
        [Range(0.01, double.MaxValue, ErrorMessage = "Amount must be greater than zero")]
        public decimal Amount { get; set; }
        
        [Required]
        [StringLength(3, MinimumLength = 3)]
        public string Currency { get; set; }
        
        [StringLength(500)]
        public string Description { get; set; }
    }

    public class TransferResponse
    {
        public string TransactionId { get; set; }
        public string Status { get; set; }
        public DateTime Timestamp { get; set; }
    }

    public interface ITransactionService
    {
        Task<TransactionResult> ProcessTransferAsync(TransferRequest request);
    }

    public class TransactionResult
    {
        public string TransactionId { get; set; }
    }

    public class InsufficientFundsException : Exception
    {
        public InsufficientFundsException(string message) : base(message) { }
    }

    public class AccountNotFoundException : Exception
    {
        public string AccountId { get; set; }
        public AccountNotFoundException(string accountId, string message) : base(message)
        {
            AccountId = accountId;
        }
    }
}