diff --git a/backend/.gitattributes b/backend/.gitattributes
new file mode 100644
index 0000000..3b41682
--- /dev/null
+++ b/backend/.gitattributes
@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf
diff --git a/backend/.gitignore b/backend/.gitignore
new file mode 100644
index 0000000..667aaef
--- /dev/null
+++ b/backend/.gitignore
@@ -0,0 +1,33 @@
+HELP.md
+target/
+.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
diff --git a/backend/.mvn/wrapper/maven-wrapper.properties b/backend/.mvn/wrapper/maven-wrapper.properties
new file mode 100644
index 0000000..12fbe1e
--- /dev/null
+++ b/backend/.mvn/wrapper/maven-wrapper.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+wrapperVersion=3.3.2
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip
diff --git a/backend/Dockerfile b/backend/Dockerfile
deleted file mode 100644
index 37fa044..0000000
--- a/backend/Dockerfile
+++ /dev/null
@@ -1,23 +0,0 @@
-FROM openjdk:17-jdk-slim
-
-WORKDIR /app
-
-# Copy Maven wrapper and pom.xml
-COPY mvnw .
-COPY .mvn .mvn
-COPY pom.xml .
-
-# Download dependencies
-RUN chmod +x ./mvnw && ./mvnw dependency:go-offline -B
-
-# Copy source code
-COPY src src
-
-# Build application
-RUN ./mvnw clean package -DskipTests
-
-# Expose port
-EXPOSE 8080
-
-# Run application
-CMD ["java", "-jar", "target/fraudguard-backend-0.0.1-SNAPSHOT.jar"]
diff --git a/backend/README.md b/backend/README.md
deleted file mode 100644
index 3a4ae8b..0000000
--- a/backend/README.md
+++ /dev/null
@@ -1 +0,0 @@
-# Backend Service - Spring Boot API
diff --git a/backend/logs/fraudguard-backend.log.2025-08-28.0.gz b/backend/logs/fraudguard-backend.log.2025-08-28.0.gz
deleted file mode 100644
index d7c06fd..0000000
Binary files a/backend/logs/fraudguard-backend.log.2025-08-28.0.gz and /dev/null differ
diff --git a/backend/mvnm b/backend/mvnm
deleted file mode 100644
index e69de29..0000000
diff --git a/backend/mvnm.cmd b/backend/mvnm.cmd
deleted file mode 100644
index e69de29..0000000
diff --git a/backend/mvnw b/backend/mvnw
new file mode 100644
index 0000000..19529dd
--- /dev/null
+++ b/backend/mvnw
@@ -0,0 +1,259 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.2
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"${0%/*}/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in ${0%/*}/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${0##*/mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"
diff --git a/backend/mvnw.cmd b/backend/mvnw.cmd
new file mode 100644
index 0000000..249bdf3
--- /dev/null
+++ b/backend/mvnw.cmd
@@ -0,0 +1,149 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.2
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" (%__MVNW_CMD__% %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace '^.*'+$MVNW_REPO_PATTERN,'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+$MAVEN_HOME_PARENT = "$HOME/.m2/wrapper/dists/$distributionUrlNameMain"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_HOME_PARENT = "$env:MAVEN_USER_HOME/wrapper/dists/$distributionUrlNameMain"
+}
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.MD5]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
diff --git a/backend/pom.xml b/backend/pom.xml
index 65498f4..70cae30 100644
--- a/backend/pom.xml
+++ b/backend/pom.xml
@@ -1,179 +1,91 @@
-<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.fraudguard</groupId>
+  <artifactId>fraudguard-backend</artifactId>
+  <version>1.1.0</version>
+  <packaging>jar</packaging>
 
-    <parent>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-starter-parent</artifactId>
-        <version>3.1.5</version>
-        <relativePath/>
-    </parent>
-
-    <groupId>com.fraudguard</groupId>
-    <artifactId>fraudguard-backend</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
-    <name>FraudGuard Backend</name>
-    <description>Fraud Detection System Backend</description>
+  <parent>
+    <groupId>org.springframework.boot</groupId>
+    <artifactId>spring-boot-starter-parent</artifactId>
+    <version>3.2.4</version>
+    <relativePath/>
+  </parent>
 
-    <properties>
-        <java.version>17</java.version>
-        <start-class>com.fraudguard.FraudGuardApplication</start-class>
-        <testcontainers.version>1.19.0</testcontainers.version>
-    </properties>
+  <properties>
+    <java.version>17</java.version>
+    <maven.compiler.source>17</maven.compiler.source>
+    <maven.compiler.target>17</maven.compiler.target>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
 
-    <dependencies>
-        <!-- Spring Web -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-web</artifactId>
-        </dependency>
-        
-        <!-- Spring Data JPA -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-data-jpa</artifactId>
-        </dependency>
-        
-        <!-- Jakarta Bean Validation (JSR 380) -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-validation</artifactId>
-        </dependency>
-        
-        <!-- Spring Security -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-security</artifactId>
-        </dependency>
-        
-        <!-- Spring Actuator (for health checks and monitoring) -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-actuator</artifactId>
-        </dependency>
-        
-        <!-- Spring Kafka (for messaging) -->
-        <dependency>
-            <groupId>org.springframework.kafka</groupId>
-            <artifactId>spring-kafka</artifactId>
-        </dependency>
-        
-        <!-- Spring Mail (for email notifications) -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-mail</artifactId>
-        </dependency>
-        
-        <!-- Lombok (for code generation) -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        
-        <!-- PostgreSQL Driver -->
-        <dependency>
-            <groupId>org.postgresql</groupId>
-            <artifactId>postgresql</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-        
-        <!-- H2 Database (for development/testing) -->
-        <dependency>
-            <groupId>com.h2database</groupId>
-            <artifactId>h2</artifactId>
-            <scope>runtime</scope>
-        </dependency>
-        
-        <!-- Jackson for JSON processing -->
-        <dependency>
-            <groupId>com.fasterxml.jackson.datatype</groupId>
-            <artifactId>jackson-datatype-jsr310</artifactId>
-        </dependency>
-        
-        <!-- HTTP Client for external API calls -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webflux</artifactId>
-        </dependency>
-        
-        <!-- Testing -->
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        
-        <!-- Spring Security Test -->
-        <dependency>
-            <groupId>org.springframework.security</groupId>
-            <artifactId>spring-security-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        
-        <!-- Spring Kafka Test -->
-        <dependency>
-            <groupId>org.springframework.kafka</groupId>
-            <artifactId>spring-kafka-test</artifactId>
-            <scope>test</scope>
-        </dependency>
-        
-        <!-- Testcontainers for integration testing -->
-        <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        
-        <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>postgresql</artifactId>
-            <scope>test</scope>
-        </dependency>
-        
-        <dependency>
-            <groupId>org.testcontainers</groupId>
-            <artifactId>kafka</artifactId>
-            <scope>test</scope>
-        </dependency>
-        
-        <!-- MockWebServer for testing external API calls -->
-        <dependency>
-            <groupId>com.squareup.okhttp3</groupId>
-            <artifactId>mockwebserver</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
+  <dependencies>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-data-jpa</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-starter-security</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.mysql</groupId>
+      <artifactId>mysql-connector-j</artifactId>
+      <version>8.0.33</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.jsonwebtoken</groupId>
+      <artifactId>jjwt-api</artifactId>
+      <version>0.11.5</version>
+    </dependency>
+    <dependency>
+      <groupId>io.jsonwebtoken</groupId>
+      <artifactId>jjwt-impl</artifactId>
+      <version>0.11.5</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.jsonwebtoken</groupId>
+      <artifactId>jjwt-jackson</artifactId>
+      <version>0.11.5</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springdoc</groupId>
+      <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
+      <version>2.3.0</version>
+    </dependency>
+    <dependency>
+      <groupId>org.projectlombok</groupId>
+      <artifactId>lombok</artifactId>
+      <version>1.18.32</version>
+      <optional>true</optional>
+    </dependency>
+  </dependencies>
 
-    <dependencyManagement>
-        <dependencies>
-            <dependency>
-                <groupId>org.testcontainers</groupId>
-                <artifactId>testcontainers-bom</artifactId>
-                <version>${testcontainers.version}</version>
-                <type>pom</type>
-                <scope>import</scope>
-            </dependency>
-        </dependencies>
-    </dependencyManagement>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.springframework.boot</groupId>
-                <artifactId>spring-boot-maven-plugin</artifactId>
-                <configuration>
-                    <mainClass>com.fraudguard.FraudGuardApplication</mainClass>
-                    <excludes>
-                        <exclude>
-                            <groupId>org.projectlombok</groupId>
-                            <artifactId>lombok</artifactId>
-                        </exclude>
-                    </excludes>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
+ <build>
+    <plugins>
+      <plugin>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.11.0</version>
+        <configuration>
+          <source>${java.version}</source>
+          <target>${java.version}</target>
+          <encoding>UTF-8</encoding>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
 </project>
diff --git a/backend/src/main/java/com/fraudguard/FraudGuardApplication.java b/backend/src/main/java/com/fraudguard/FraudGuardApplication.java
index 54eb633..39e6675 100644
--- a/backend/src/main/java/com/fraudguard/FraudGuardApplication.java
+++ b/backend/src/main/java/com/fraudguard/FraudGuardApplication.java
@@ -1,174 +1,12 @@
+
 package com.fraudguard;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.context.event.ApplicationReadyEvent;
-import org.springframework.cache.annotation.EnableCaching;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.event.EventListener;
-import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
-import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
-import org.springframework.scheduling.annotation.EnableAsync;
-import org.springframework.scheduling.annotation.EnableScheduling;
-import org.springframework.transaction.annotation.EnableTransactionManagement;
-import org.springframework.web.cors.CorsConfiguration;
-import org.springframework.web.cors.CorsConfigurationSource;
-import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
-import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
-
-import java.time.LocalDateTime;
-import java.time.format.DateTimeFormatter;
-import java.util.Arrays;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ThreadPoolExecutor;
 
 @SpringBootApplication
-@EnableJpaRepositories(basePackages = "com.fraudguard.repository")
-@EnableJpaAuditing
-@EnableTransactionManagement
-@EnableCaching
-@EnableAsync
-@EnableScheduling
 public class FraudGuardApplication {
-
-    private static final Logger logger = LoggerFactory.getLogger(FraudGuardApplication.class);
-
     public static void main(String[] args) {
-        // Performance optimizations
-        System.setProperty("spring.jpa.open-in-view", "false");
-        System.setProperty("spring.jpa.hibernate.use-new-id-generator-mappings", "true");
-        System.setProperty("spring.jpa.hibernate.jdbc.batch_size", "50");
-        System.setProperty("spring.jpa.hibernate.order_inserts", "true");
-        System.setProperty("spring.jpa.hibernate.order_updates", "true");
-
-        SpringApplication app = new SpringApplication(FraudGuardApplication.class);
-
-        // Add shutdown hook for graceful shutdown
-        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            logger.info("🛑 FraudGuard Application is shutting down gracefully...");
-        }));
-
-        app.run(args);
-    }
-
-    @EventListener(ApplicationReadyEvent.class)
-    public void onApplicationReady() {
-        displayStartupBanner();
-        logSystemConfiguration();
-        verifySystemHealth();
-    }
-
-    private void displayStartupBanner() {
-        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
-
-        System.out.println();
-        System.out.println("╔══════════════════════════════════════════════════════════╗");
-        System.out.println("║          🛡️  FRAUDGUARD FRAUD DETECTION SYSTEM          ║");
-        System.out.println("║                   Successfully Started                   ║");
-        System.out.println("╠══════════════════════════════════════════════════════════╣");
-        System.out.println("║  🚀 Application: FraudGuard Backend API                 ║");
-        System.out.println("║  ⏰ Started At: " + String.format("%-35s", timestamp) + " ║");
-        System.out.println("║  🌐 Environment: " + String.format("%-34s", getActiveProfile()) + " ║");
-        System.out.println("║  📊 Server Port: " + String.format("%-34s", getServerPort()) + " ║");
-        System.out.println("╠══════════════════════════════════════════════════════════╣");
-        System.out.println("║                    🔗 QUICK LINKS                        ║");
-        System.out.println("║  Health Check: http://localhost:" + getServerPort() + "/actuator/health    ║");
-        System.out.println("║  API Docs: http://localhost:" + getServerPort() + "/swagger-ui.html       ║");
-        System.out.println("║  Endpoints: http://localhost:" + getServerPort() + "/api-docs            ║");
-        System.out.println("╠══════════════════════════════════════════════════════════╣");
-        System.out.println("║              🔐 FRAUD DETECTION FEATURES                 ║");
-        System.out.println("║  ✅ Real-time Transaction Monitoring                    ║");
-        System.out.println("║  ✅ Machine Learning Risk Scoring                       ║");
-        System.out.println("║  ✅ Behavioral Pattern Analysis                         ║");
-        System.out.println("║  ✅ Velocity and Amount Checking                        ║");
-        System.out.println("║  ✅ Geolocation Anomaly Detection                       ║");
-        System.out.println("║  ✅ Device Fingerprint Analysis                         ║");
-        System.out.println("║  ✅ Alert Management System                             ║");
-        System.out.println("║  ✅ Case Investigation Workflow                         ║");
-        System.out.println("╚══════════════════════════════════════════════════════════╝");
-        System.out.println();
-
-        logger.info("🛡️ FraudGuard is now protecting your transactions!");
-    }
-
-    private void logSystemConfiguration() {
-        Runtime runtime = Runtime.getRuntime();
-        logger.info("💾 System Resources - Max Memory: {} MB, Available Processors: {}",
-                runtime.maxMemory() / (1024 * 1024), runtime.availableProcessors());
-        logger.info("☕ Java Runtime - Version: {}, Vendor: {}",
-                System.getProperty("java.version"), System.getProperty("java.vendor"));
-    }
-
-    private void verifySystemHealth() {
-        try {
-            // Add any startup health checks here
-            logger.info("✅ System health check passed - All components ready");
-        } catch (Exception e) {
-            logger.error("❌ System health check failed: {}", e.getMessage(), e);
-        }
-    }
-
-    private String getActiveProfile() {
-        String profiles = System.getProperty("spring.profiles.active");
-        return profiles != null ? profiles : "default";
-    }
-
-    private String getServerPort() {
-        return System.getProperty("server.port", "8080");
-    }
-
-    /** Configure Jackson ObjectMapper for proper JSON handling */
-    @Bean
-    public ObjectMapper objectMapper() {
-        ObjectMapper mapper = new ObjectMapper();
-        mapper.registerModule(new JavaTimeModule());
-        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
-        mapper.enable(SerializationFeature.INDENT_OUTPUT);
-        return mapper;
-    }
-
-    /** Configure CORS settings for frontend integration */
-    @Bean
-    public CorsConfigurationSource corsConfigurationSource() {
-        CorsConfiguration configuration = new CorsConfiguration();
-        configuration.setAllowedOriginPatterns(Arrays.asList("*"));
-        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS"));
-        configuration.setAllowedHeaders(Arrays.asList("*"));
-        configuration.setAllowCredentials(true);
-
-        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
-        source.registerCorsConfiguration("/**", configuration);
-        return source;
-    }
-
-    /** Configure async task executor for fraud detection processing */
-    @Bean(name = "fraudDetectionExecutor")
-    public Executor fraudDetectionExecutor() {
-        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
-        executor.setCorePoolSize(5);
-        executor.setMaxPoolSize(20);
-        executor.setQueueCapacity(100);
-        executor.setThreadNamePrefix("FraudDetection-");
-        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
-        executor.initialize();
-        return executor;
-    }
-
-    /** Configure async task executor for alert processing */
-    @Bean(name = "alertProcessingExecutor")
-    public Executor alertProcessingExecutor() {
-        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
-        executor.setCorePoolSize(3);
-        executor.setMaxPoolSize(10);
-        executor.setQueueCapacity(50);
-        executor.setThreadNamePrefix("AlertProcessing-");
-        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
-        executor.initialize();
-        return executor;
+        SpringApplication.run(FraudGuardApplication.class, args);
     }
 }
diff --git a/backend/src/main/java/com/fraudguard/config/SecurityConfig.java b/backend/src/main/java/com/fraudguard/config/SecurityConfig.java
index 598df18..36b666d 100644
--- a/backend/src/main/java/com/fraudguard/config/SecurityConfig.java
+++ b/backend/src/main/java/com/fraudguard/config/SecurityConfig.java
@@ -1,23 +1,94 @@
+// com/fraudguard/config/SecurityConfig.java
 package com.fraudguard.config;
 
+import com.fraudguard.security.JwtAuthFilter;
+import com.fraudguard.security.JwtService;
+import com.fraudguard.service.UserService;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.ProviderManager;
+import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
-import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.cors.CorsConfigurationSource;
+import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
+
+import java.util.Arrays;
+import java.util.List;
 
 @Configuration
-@EnableWebSecurity
+@EnableMethodSecurity
 public class SecurityConfig {
 
+    private final JwtService jwtService;
+
+    public SecurityConfig(JwtService jwtService) {
+        this.jwtService = jwtService;
+    }
+
+    // 2.1 Expose UserDetailsService via your UserService (no constructor injection)
+    // @Bean
+    // public UserDetailsService userDetailsService(UserService userService) {
+    //     return userService; // UserService implements UserDetailsService
+    // }
+
+    // 2.2 Password encoder
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    // 2.3 Auth manager wired with UDS + encoder
+    @Bean
+    public AuthenticationManager authenticationManager(UserDetailsService uds, PasswordEncoder encoder) {
+        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
+        provider.setUserDetailsService(uds);
+        provider.setPasswordEncoder(encoder);
+        return new ProviderManager(provider);
+    }
+
+    // 2.4 Jwt filter as a bean (inject UDS here)
+    @Bean
+    public JwtAuthFilter jwtAuthFilter(UserDetailsService uds) {
+        return new JwtAuthFilter(jwtService, uds);
+    }
+
+    // 2.5 Security filter chain (inject the filter as a parameter)
     @Bean
-    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+    public SecurityFilterChain filterChain(HttpSecurity http, JwtAuthFilter jwtAuthFilter) throws Exception {
         http
+            .cors(c -> c.configurationSource(corsConfigurationSource()))
+            .csrf(csrf -> csrf.disable())
+            .sessionManagement(sess -> sess.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
             .authorizeHttpRequests(auth -> auth
-                .anyRequest().permitAll()
+                .requestMatchers("/api/auth/**", "/swagger-ui/**", "/v3/api-docs/**", "/api-docs/**").permitAll()
+                .requestMatchers(HttpMethod.GET, "/actuator/health").permitAll()
+                .anyRequest().authenticated()
             )
-            .csrf(csrf -> csrf.disable());
-        
+            .addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class);
+
         return http.build();
     }
+
+    // 2.6 CORS (adjust origins as needed)
+    @Bean
+    public CorsConfigurationSource corsConfigurationSource() {
+        CorsConfiguration config = new CorsConfiguration();
+        config.setAllowedOrigins(List.of("http://localhost:3000","http://127.0.0.1:5500"));
+        config.setAllowedMethods(Arrays.asList("GET","POST","PUT","DELETE","OPTIONS"));
+        config.setAllowedHeaders(Arrays.asList("Authorization","Content-Type"));
+        config.setAllowCredentials(true);
+        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
+        source.registerCorsConfiguration("/**", config);
+        return source;
+    }
 }
diff --git a/backend/src/main/java/com/fraudguard/config/SwaggerConfig.java b/backend/src/main/java/com/fraudguard/config/SwaggerConfig.java
new file mode 100644
index 0000000..c51a5cc
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/config/SwaggerConfig.java
@@ -0,0 +1,18 @@
+
+package com.fraudguard.config;
+
+import io.swagger.v3.oas.models.OpenAPI;
+import io.swagger.v3.oas.models.info.Info;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class SwaggerConfig {
+    @Bean
+    public OpenAPI openAPI() {
+        return new OpenAPI().info(new Info()
+            .title("FraudGuard API")
+            .description("Fraud detection backend with JWT + MySQL")
+            .version("1.1.0"));
+    }
+}
diff --git a/backend/src/main/java/com/fraudguard/controller/AlertController.java b/backend/src/main/java/com/fraudguard/controller/AlertController.java
new file mode 100644
index 0000000..f07a61c
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/controller/AlertController.java
@@ -0,0 +1,24 @@
+
+package com.fraudguard.controller;
+
+import com.fraudguard.model.Alert;
+import com.fraudguard.service.AlertService;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/alerts")
+public class AlertController {
+    private final AlertService service;
+
+    public AlertController(AlertService service) {
+        this.service = service;
+    }
+
+    @GetMapping
+    public List<Alert> all() { return service.findAll(); }
+
+    @PostMapping
+    public Alert create(@RequestBody Alert alert) { return service.save(alert); }
+}
diff --git a/backend/src/main/java/com/fraudguard/controller/AuthController.java b/backend/src/main/java/com/fraudguard/controller/AuthController.java
new file mode 100644
index 0000000..9a34559
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/controller/AuthController.java
@@ -0,0 +1,42 @@
+
+package com.fraudguard.controller;
+
+import com.fraudguard.dto.AuthRequest;
+import com.fraudguard.dto.AuthResponse;
+import com.fraudguard.model.User;
+import com.fraudguard.security.JwtService;
+import com.fraudguard.service.UserService;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+@RestController
+@RequestMapping("/api/auth")
+public class AuthController {
+
+    private final UserService userService;
+    private final JwtService jwtService;
+    private final AuthenticationManager authManager;
+
+    public AuthController(UserService userService, JwtService jwtService, AuthenticationManager authManager) {
+        this.userService = userService;
+        this.jwtService = jwtService;
+        this.authManager = authManager;
+    }
+
+    @PostMapping("/register")
+    public ResponseEntity<String> register(@RequestBody User user) {
+        userService.register(user);
+        return ResponseEntity.ok("User registered");
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<AuthResponse> login(@RequestBody AuthRequest req) {
+        authManager.authenticate(new UsernamePasswordAuthenticationToken(req.getUsername(), req.getPassword()));
+        String token = jwtService.generateToken(req.getUsername());
+        return ResponseEntity.ok(new AuthResponse(token));
+    }
+}
diff --git a/backend/src/main/java/com/fraudguard/controller/CustomerController.java b/backend/src/main/java/com/fraudguard/controller/CustomerController.java
new file mode 100644
index 0000000..d5e0e50
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/controller/CustomerController.java
@@ -0,0 +1,25 @@
+
+package com.fraudguard.controller;
+
+import com.fraudguard.model.Customer;
+import com.fraudguard.repository.CustomerRepository;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/customers")
+public class CustomerController {
+
+    private final CustomerRepository repo;
+
+    public CustomerController(CustomerRepository repo) {
+        this.repo = repo;
+    }
+
+    @GetMapping
+    public List<Customer> all() { return repo.findAll(); }
+
+    @PostMapping
+    public Customer create(@RequestBody Customer c) { return repo.save(c); }
+}
diff --git a/backend/src/main/java/com/fraudguard/controller/NetworkController.java b/backend/src/main/java/com/fraudguard/controller/NetworkController.java
new file mode 100644
index 0000000..66e00d9
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/controller/NetworkController.java
@@ -0,0 +1,28 @@
+
+package com.fraudguard.controller;
+
+import com.fraudguard.dto.NetworkGraph;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/network")
+public class NetworkController {
+
+    @GetMapping("/analysis")
+    public NetworkGraph analysis() {
+        var nodes = List.of(
+                new NetworkGraph.Node("C1","Global Imports Inc.","COMPANY"),
+                new NetworkGraph.Node("P1","John D. Smith","PERSON"),
+                new NetworkGraph.Node("EX1","Crypto Exchange","EXCHANGE")
+        );
+        var edges = List.of(
+                new NetworkGraph.Edge("C1","EX1", 47800.0),
+                new NetworkGraph.Edge("P1","EX1", 18450.0)
+        );
+        return new NetworkGraph(nodes, edges);
+    }
+}
diff --git a/backend/src/main/java/com/fraudguard/controller/ReportController.java b/backend/src/main/java/com/fraudguard/controller/ReportController.java
new file mode 100644
index 0000000..341581b
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/controller/ReportController.java
@@ -0,0 +1,24 @@
+
+package com.fraudguard.controller;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+@RestController
+@RequestMapping("/api/reports")
+public class ReportController {
+
+    @GetMapping("/summary")
+    public Map<String, Object> summary() {
+        return Map.of(
+                "totalAlerts", 142,
+                "highPriority", 27,
+                "sarsFiled", 18,
+                "avgInvestigationHours", 3.2,
+                "modelAccuracy", Map.of("XGBoost", 0.92, "GNN", 0.89, "RuleEngine", 0.76)
+        );
+    }
+}
diff --git a/backend/src/main/java/com/fraudguard/controller/UserController.java b/backend/src/main/java/com/fraudguard/controller/UserController.java
deleted file mode 100644
index 7b8a1cf..0000000
--- a/backend/src/main/java/com/fraudguard/controller/UserController.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package com.fraudguard.controller;
-
-import com.fraudguard.dto.UserCreateRequest;
-import com.fraudguard.model.User;
-import com.fraudguard.service.UserService;
-import jakarta.validation.Valid;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.*;
-
-@RestController
-@RequestMapping("/users")
-@RequiredArgsConstructor
-@Slf4j
-public class UserController {
-    
-    private final UserService userService;
-    
-    @PostMapping
-    @ResponseStatus(HttpStatus.CREATED)
-    public User createUser(@Valid @RequestBody UserCreateRequest request) {
-        log.info("Received request to create user: {}", request.getEmail());
-        return userService.createUser(request);
-    }
-    
-    @GetMapping("/{email}")
-    public User getUser(@PathVariable String email) {
-        log.info("Fetching user by email: {}", email);
-        return userService.findByEmail(email);
-    }
-}
diff --git a/backend/src/main/java/com/fraudguard/dto/AuthRequest.java b/backend/src/main/java/com/fraudguard/dto/AuthRequest.java
new file mode 100644
index 0000000..4f7b2e8
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/dto/AuthRequest.java
@@ -0,0 +1,21 @@
+package com.fraudguard.dto;
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+@Data
+@Getter
+@Setter
+public class AuthRequest {
+    private String username;
+    private String password;
+
+    public String getUsername() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    public Object getPassword() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+}
diff --git a/backend/src/main/java/com/fraudguard/dto/AuthResponse.java b/backend/src/main/java/com/fraudguard/dto/AuthResponse.java
new file mode 100644
index 0000000..8f50a08
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/dto/AuthResponse.java
@@ -0,0 +1,19 @@
+
+package com.fraudguard.dto;
+
+
+import lombok.Data;
+import lombok.Getter;
+import lombok.Setter;
+
+@Data
+@Setter
+@Getter
+public class AuthResponse {
+
+    public AuthResponse(String token2) {
+        //TODO Auto-generated constructor stub
+    }
+
+    private String token;
+}
diff --git a/backend/src/main/java/com/fraudguard/dto/NetworkGraph.java b/backend/src/main/java/com/fraudguard/dto/NetworkGraph.java
new file mode 100644
index 0000000..5617a26
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/dto/NetworkGraph.java
@@ -0,0 +1,9 @@
+
+package com.fraudguard.dto;
+
+import java.util.List;
+
+public record NetworkGraph(List<Node> nodes, List<Edge> edges) {
+    public record Node(String id, String label, String type) {}
+    public record Edge(String from, String to, double weight) {}
+}
diff --git a/backend/src/main/java/com/fraudguard/dto/UserCreateRequest.java b/backend/src/main/java/com/fraudguard/dto/UserCreateRequest.java
deleted file mode 100644
index 1fc9f38..0000000
--- a/backend/src/main/java/com/fraudguard/dto/UserCreateRequest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package com.fraudguard.dto;
-
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Size;
-import lombok.Data;
-
-@Data
-public class UserCreateRequest {
-    @NotBlank(message = "Email is required")
-    @Email(message = "Invalid email format")
-    private String email;
-    
-    @NotBlank(message = "First name is required")
-    @Size(min = 1, max = 100)
-    private String firstName;
-    
-    @NotBlank(message = "Last name is required")
-    @Size(min = 1, max = 100)
-    private String lastName;
-    
-    @Size(max = 20)
-    private String phoneNumber;
-    
-    @Size(max = 100)
-    private String city;
-    
-    @Size(max = 100)
-    private String country;
-}
diff --git a/backend/src/main/java/com/fraudguard/model/AccountStatus.java b/backend/src/main/java/com/fraudguard/model/AccountStatus.java
deleted file mode 100644
index c794e4a..0000000
--- a/backend/src/main/java/com/fraudguard/model/AccountStatus.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package com.fraudguard.model;
-
-public enum AccountStatus {
-    ACTIVE("Account is active"),
-    SUSPENDED("Account is suspended"),
-    BLOCKED("Account is blocked"),
-    PENDING_VERIFICATION("Account pending verification"),
-    CLOSED("Account is closed");
-    
-    private final String description;
-    
-    AccountStatus(String description) {
-        this.description = description;
-    }
-    
-    public String getDescription() {
-        return description;
-    }
-    
-    public boolean isActive() {
-        return this == ACTIVE;
-    }
-    
-    public boolean isBlocked() {
-        return this == BLOCKED || this == SUSPENDED;
-    }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/Alert.java b/backend/src/main/java/com/fraudguard/model/Alert.java
new file mode 100644
index 0000000..793ac0f
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/model/Alert.java
@@ -0,0 +1,18 @@
+
+package com.fraudguard.model;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+@Entity
+@Getter @Setter @NoArgsConstructor @AllArgsConstructor @Builder
+public class Alert {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String title;
+    private String description;
+    private String severity; // HIGH/MEDIUM/LOW
+    private String status;   // NEW/IN_REVIEW/ESCALATED/SAR_PREPARED
+}
diff --git a/backend/src/main/java/com/fraudguard/model/AlertAction.java b/backend/src/main/java/com/fraudguard/model/AlertAction.java
deleted file mode 100644
index 98674e3..0000000
--- a/backend/src/main/java/com/fraudguard/model/AlertAction.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package com.fraudguard.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "alert_actions", indexes = {
-    @Index(name = "idx_action_alert", columnList = "fraud_alert_id"),
-    @Index(name = "idx_action_created", columnList = "created_at")
-})
-public class AlertAction {
-    
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "fraud_alert_id", nullable = false)
-    private FraudAlert fraudAlert;
-    
-    @Column(name = "action_type", nullable = false, length = 100)
-    private String actionType; // BLOCK_CARD, REQUIRE_2FA, NOTIFY_USER, etc.
-    
-    @Column(name = "action_status", nullable = false, length = 50)
-    private String actionStatus; // PENDING, COMPLETED, FAILED
-    
-    @Column(name = "description", columnDefinition = "TEXT")
-    private String description;
-    
-    @Column(name = "performed_by", length = 100)
-    private String performedBy;
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "completed_at")
-    private LocalDateTime completedAt;
-    
-    // Constructors
-    public AlertAction() {
-        this.createdAt = LocalDateTime.now();
-    }
-    
-    public AlertAction(FraudAlert fraudAlert, String actionType, String description) {
-        this();
-        this.fraudAlert = fraudAlert;
-        this.actionType = actionType;
-        this.description = description;
-        this.actionStatus = "PENDING";
-    }
-    
-    // Utility methods
-    public void complete() {
-        this.actionStatus = "COMPLETED";
-        this.completedAt = LocalDateTime.now();
-    }
-    
-    public void fail() {
-        this.actionStatus = "FAILED";
-        this.completedAt = LocalDateTime.now();
-    }
-    
-    public boolean isPending() {
-        return "PENDING".equals(actionStatus);
-    }
-    
-    public boolean isCompleted() {
-        return "COMPLETED".equals(actionStatus);
-    }
-    
-    // Getters and Setters
-    public Long getId() { return id; }
-    public void setId(Long id) { this.id = id; }
-    
-    public FraudAlert getFraudAlert() { return fraudAlert; }
-    public void setFraudAlert(FraudAlert fraudAlert) { this.fraudAlert = fraudAlert; }
-    
-    public String getActionType() { return actionType; }
-    public void setActionType(String actionType) { this.actionType = actionType; }
-    
-    public String getActionStatus() { return actionStatus; }
-    public void setActionStatus(String actionStatus) { this.actionStatus = actionStatus; }
-    
-    public String getDescription() { return description; }
-    public void setDescription(String description) { this.description = description; }
-    
-    public String getPerformedBy() { return performedBy; }
-    public void setPerformedBy(String performedBy) { this.performedBy = performedBy; }
-    
-    public LocalDateTime getCreatedAt() { return createdAt; }
-    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
-    
-    public LocalDateTime getCompletedAt() { return completedAt; }
-    public void setCompletedAt(LocalDateTime completedAt) { this.completedAt = completedAt; }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/AlertSeverity.java b/backend/src/main/java/com/fraudguard/model/AlertSeverity.java
deleted file mode 100644
index 7bd7205..0000000
--- a/backend/src/main/java/com/fraudguard/model/AlertSeverity.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package com.fraudguard.model;
-
-public enum AlertSeverity {
-    LOW("Low risk alert"),
-    MEDIUM("Medium risk alert"),
-    HIGH("High risk alert"),
-    CRITICAL("Critical risk alert");
-    
-    private final String description;
-    
-    AlertSeverity(String description) {
-        this.description = description;
-    }
-    
-    public String getDescription() {
-        return description;
-    }
-    
-    public int getPriorityLevel() {
-        switch (this) {
-            case LOW: return 1;
-            case MEDIUM: return 2;
-            case HIGH: return 3;
-            case CRITICAL: return 4;
-            default: return 0;
-        }
-    }
-    
-    public boolean requiresImmediateAttention() {
-        return this == HIGH || this == CRITICAL;
-    }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/AlertStatus.java b/backend/src/main/java/com/fraudguard/model/AlertStatus.java
deleted file mode 100644
index fd2e5bb..0000000
--- a/backend/src/main/java/com/fraudguard/model/AlertStatus.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package com.fraudguard.model;
-
-public enum AlertStatus {
-    OPEN("Alert is open and needs investigation"),
-    IN_PROGRESS("Alert is being investigated"),
-    RESOLVED("Alert has been resolved"),
-    FALSE_POSITIVE("Alert was a false positive"),
-    ESCALATED("Alert has been escalated");
-    
-    private final String description;
-    
-    AlertStatus(String description) {
-        this.description = description;
-    }
-    
-    public String getDescription() {
-        return description;
-    }
-    
-    public boolean isActive() {
-        return this == OPEN || this == IN_PROGRESS || this == ESCALATED;
-    }
-    
-    public boolean isClosed() {
-        return this == RESOLVED || this == FALSE_POSITIVE;
-    }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/Customer.java b/backend/src/main/java/com/fraudguard/model/Customer.java
new file mode 100644
index 0000000..3c5772b
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/model/Customer.java
@@ -0,0 +1,17 @@
+
+package com.fraudguard.model;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+@Entity
+@Getter @Setter @NoArgsConstructor @AllArgsConstructor @Builder
+public class Customer {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String name;
+    private String riskLevel; // HIGH/MEDIUM/LOW
+    private String notes;
+}
diff --git a/backend/src/main/java/com/fraudguard/model/FeatureType.java b/backend/src/main/java/com/fraudguard/model/FeatureType.java
deleted file mode 100644
index 2fe6d77..0000000
--- a/backend/src/main/java/com/fraudguard/model/FeatureType.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.fraudguard.model;
-
-public enum FeatureType {
-    AMOUNT, FREQUENCY, LOCATION, TIME, DEVICE
-}
diff --git a/backend/src/main/java/com/fraudguard/model/FraudAlert.java b/backend/src/main/java/com/fraudguard/model/FraudAlert.java
deleted file mode 100644
index ddf28be..0000000
--- a/backend/src/main/java/com/fraudguard/model/FraudAlert.java
+++ /dev/null
@@ -1,183 +0,0 @@
-package com.fraudguard.model;
-
-import java.math.BigDecimal;
-import jakarta.persistence.*;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.NotNull;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-
-@Entity
-@Table(name = "fraud_alerts", indexes = {
-    @Index(name = "idx_alert_transaction", columnList = "transaction_id"),
-    @Index(name = "idx_alert_severity", columnList = "severity"),
-    @Index(name = "idx_alert_status", columnList = "status"),
-    @Index(name = "idx_alert_created", columnList = "created_at")
-})
-public class FraudAlert {
-    
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "transaction_id", nullable = false)
-    private Transaction transaction;
-    
-    @NotBlank(message = "Alert type is required")
-    @Column(name = "alert_type", nullable = false, length = 100)
-    private String alertType;
-    
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false)
-    private AlertSeverity severity = AlertSeverity.MEDIUM;
-    
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false)
-    private AlertStatus status = AlertStatus.OPEN;
-    
-    @Column(columnDefinition = "TEXT")
-    private String reason;
-    
-    @Column(columnDefinition = "TEXT")
-    private String description;
-    
-    // FIXED: Changed from Double to BigDecimal
-    @NotNull(message = "Confidence score is required")
-    @Column(name = "confidence_score", precision = 5, scale = 2)
-    private BigDecimal confidenceScore;
-    
-    @Column(name = "rule_triggered", length = 255)
-    private String ruleTriggered;
-    
-    @Column(name = "model_version", length = 50)
-    private String modelVersion;
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "updated_at", nullable = false)
-    private LocalDateTime updatedAt;
-    
-    @Column(name = "resolved_at")
-    private LocalDateTime resolvedAt;
-    
-    @Column(name = "resolved_by", length = 100)
-    private String resolvedBy;
-    
-    @Column(name = "resolution_notes", columnDefinition = "TEXT")
-    private String resolutionNotes;
-    
-    @JsonIgnore
-    @OneToMany(mappedBy = "fraudAlert", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    private List<AlertAction> actions = new ArrayList<>();
-    
-    // Constructors
-    public FraudAlert() {
-        LocalDateTime now = LocalDateTime.now();
-        this.createdAt = now;
-        this.updatedAt = now;
-    }
-    
-    public FraudAlert(Transaction transaction, String alertType, AlertSeverity severity, String reason) {
-        this();
-        this.transaction = transaction;
-        this.alertType = alertType;
-        this.severity = severity;
-        this.reason = reason;
-    }
-    
-    // Lifecycle callbacks
-    @PrePersist
-    protected void onCreate() {
-        LocalDateTime now = LocalDateTime.now();
-        this.createdAt = now;
-        this.updatedAt = now;
-    }
-    
-    @PreUpdate
-    protected void onUpdate() {
-        this.updatedAt = LocalDateTime.now();
-    }
-    
-    // Utility methods
-    public boolean isOpen() {
-        return status == AlertStatus.OPEN;
-    }
-    
-    public boolean isCritical() {
-        return severity == AlertSeverity.CRITICAL;
-    }
-    
-    public boolean isResolved() {
-        return status == AlertStatus.RESOLVED || status == AlertStatus.FALSE_POSITIVE;
-    }
-    
-    public void resolve(String resolvedBy, String notes) {
-        this.status = AlertStatus.RESOLVED;
-        this.resolvedBy = resolvedBy;
-        this.resolutionNotes = notes;
-        this.resolvedAt = LocalDateTime.now();
-    }
-    
-    public void markAsFalsePositive(String resolvedBy, String notes) {
-        this.status = AlertStatus.FALSE_POSITIVE;
-        this.resolvedBy = resolvedBy;
-        this.resolutionNotes = notes;
-        this.resolvedAt = LocalDateTime.now();
-    }
-    
-    // Getters and Setters (updated for BigDecimal)
-    public Long getId() { return id; }
-    public void setId(Long id) { this.id = id; }
-    
-    public Transaction getTransaction() { return transaction; }
-    public void setTransaction(Transaction transaction) { this.transaction = transaction; }
-    
-    public String getAlertType() { return alertType; }
-    public void setAlertType(String alertType) { this.alertType = alertType; }
-    
-    public AlertSeverity getSeverity() { return severity; }
-    public void setSeverity(AlertSeverity severity) { this.severity = severity; }
-    
-    public AlertStatus getStatus() { return status; }
-    public void setStatus(AlertStatus status) { this.status = status; }
-    
-    public String getReason() { return reason; }
-    public void setReason(String reason) { this.reason = reason; }
-    
-    public String getDescription() { return description; }
-    public void setDescription(String description) { this.description = description; }
-    
-    // UPDATED: BigDecimal getter/setter
-    public BigDecimal getConfidenceScore() { return confidenceScore; }
-    public void setConfidenceScore(BigDecimal confidenceScore) { this.confidenceScore = confidenceScore; }
-    
-    public String getRuleTriggered() { return ruleTriggered; }
-    public void setRuleTriggered(String ruleTriggered) { this.ruleTriggered = ruleTriggered; }
-    
-    public String getModelVersion() { return modelVersion; }
-    public void setModelVersion(String modelVersion) { this.modelVersion = modelVersion; }
-    
-    public LocalDateTime getCreatedAt() { return createdAt; }
-    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
-    
-    public LocalDateTime getUpdatedAt() { return updatedAt; }
-    public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
-    
-    public LocalDateTime getResolvedAt() { return resolvedAt; }
-    public void setResolvedAt(LocalDateTime resolvedAt) { this.resolvedAt = resolvedAt; }
-    
-    public String getResolvedBy() { return resolvedBy; }
-    public void setResolvedBy(String resolvedBy) { this.resolvedBy = resolvedBy; }
-    
-    public String getResolutionNotes() { return resolutionNotes; }
-    public void setResolutionNotes(String resolutionNotes) { this.resolutionNotes = resolutionNotes; }
-    
-    public List<AlertAction> getActions() { return actions; }
-    public void setActions(List<AlertAction> actions) { this.actions = actions; }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/PaymentMethod.java b/backend/src/main/java/com/fraudguard/model/PaymentMethod.java
deleted file mode 100644
index b439861..0000000
--- a/backend/src/main/java/com/fraudguard/model/PaymentMethod.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.fraudguard.model;
-
-public enum PaymentMethod {
-    CREDIT_CARD, DEBIT_CARD, BANK_TRANSFER, DIGITAL_WALLET, CRYPTOCURRENCY
-}
diff --git a/backend/src/main/java/com/fraudguard/model/Sar.java b/backend/src/main/java/com/fraudguard/model/Sar.java
new file mode 100644
index 0000000..37d4a7a
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/model/Sar.java
@@ -0,0 +1,22 @@
+
+package com.fraudguard.model;
+
+import jakarta.persistence.*;
+import lombok.*;
+import java.time.LocalDate;
+
+@Entity
+@Getter 
+@Setter 
+@NoArgsConstructor 
+@AllArgsConstructor 
+@Builder
+public class Sar {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String subject;
+    private String status; // PREPARED/SUBMITTED/CLOSED
+    private LocalDate createdDate;
+}
diff --git a/backend/src/main/java/com/fraudguard/model/Transaction.java b/backend/src/main/java/com/fraudguard/model/Transaction.java
deleted file mode 100644
index 8a46b18..0000000
--- a/backend/src/main/java/com/fraudguard/model/Transaction.java
+++ /dev/null
@@ -1,283 +0,0 @@
-package com.fraudguard.model;
-
-import jakarta.persistence.*;
-import jakarta.validation.constraints.DecimalMin;
-import jakarta.validation.constraints.NotNull;
-import jakarta.validation.constraints.Size;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
-
-@Entity
-@Table(name = "transactions", indexes = {
-    @Index(name = "idx_transaction_user", columnList = "user_id"),
-    @Index(name = "idx_transaction_time", columnList = "transaction_time"),
-    @Index(name = "idx_transaction_status", columnList = "status"),
-    @Index(name = "idx_transaction_fraud_score", columnList = "fraud_score"),
-    @Index(name = "idx_transaction_amount", columnList = "amount")
-})
-public class Transaction {
-    
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    private User user;
-    
-    @NotNull(message = "Amount is required")
-    @DecimalMin(value = "0.01", message = "Amount must be greater than 0")
-    @Column(precision = 15, scale = 2, nullable = false)
-    private BigDecimal amount;
-    
-    @NotNull(message = "Merchant is required")
-    @Size(max = 255, message = "Merchant name cannot exceed 255 characters")
-    @Column(nullable = false)
-    private String merchant;
-    
-    @Size(max = 100, message = "Category cannot exceed 100 characters")
-    private String category;
-    
-    @Size(max = 255, message = "Location cannot exceed 255 characters")
-    private String location;
-    
-    @Column(name = "transaction_time", nullable = false)
-    private LocalDateTime transactionTime;
-    
-    @Enumerated(EnumType.STRING)
-    @Column(nullable = false)
-    private TransactionStatus status = TransactionStatus.PENDING;
-    
-    @Column(name = "fraud_score", precision = 3, scale = 2)
-    private BigDecimal fraudScore = BigDecimal.ZERO;
-    
-    @Column(name = "transaction_type", length = 50)
-    private String transactionType;
-    
-    @Column(name = "payment_method", length = 50)
-    private String paymentMethod;
-    
-    @Column(name = "card_last_four", length = 4)
-    private String cardLastFour;
-    
-    @Column(name = "merchant_category_code", length = 10)
-    private String merchantCategoryCode;
-    
-    @Column(name = "currency_code", length = 3)
-    private String currencyCode = "USD";
-    
-    @Column(name = "ip_address", length = 45)
-    private String ipAddress;
-    
-    @Column(name = "device_fingerprint")
-    private String deviceFingerprint;
-    
-    @Column(name = "latitude")
-    private Double latitude;
-    
-    @Column(name = "longitude")
-    private Double longitude;
-    
-    @Column(name = "is_weekend")
-    private Boolean isWeekend;
-    
-    @Column(name = "is_night_time")
-    private Boolean isNightTime;
-    
-    @Column(name = "days_since_last_transaction")
-    private Integer daysSinceLastTransaction;
-    
-    @Column(name = "velocity_1h")
-    private Integer velocity1h = 0;
-    
-    @Column(name = "velocity_24h")
-    private Integer velocity24h = 0;
-    
-    @Column(name = "velocity_7d")
-    private Integer velocity7d = 0;
-    
-    @Column(name = "amount_1h")
-    private BigDecimal amount1h = BigDecimal.ZERO;
-    
-    @Column(name = "amount_24h")
-    private BigDecimal amount24h = BigDecimal.ZERO;
-    
-    @Column(name = "amount_7d")
-    private BigDecimal amount7d = BigDecimal.ZERO;
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "updated_at", nullable = false)
-    private LocalDateTime updatedAt;
-    
-    @Column(name = "processed_at")
-    private LocalDateTime processedAt;
-    
-    @JsonIgnore
-    @OneToMany(mappedBy = "transaction", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    private List<FraudAlert> fraudAlerts = new ArrayList<>();
-    
-    @JsonIgnore
-    @OneToMany(mappedBy = "transaction", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    private List<TransactionFeature> features = new ArrayList<>();
-    
-    // Constructors
-    public Transaction() {
-        LocalDateTime now = LocalDateTime.now();
-        this.transactionTime = now;
-        this.createdAt = now;
-        this.updatedAt = now;
-    }
-    
-    public Transaction(User user, BigDecimal amount, String merchant) {
-        this();
-        this.user = user;
-        this.amount = amount;
-        this.merchant = merchant;
-    }
-    
-    // Lifecycle callbacks
-    @PrePersist
-    protected void onCreate() {
-        LocalDateTime now = LocalDateTime.now();
-        if (this.transactionTime == null) {
-            this.transactionTime = now;
-        }
-        this.createdAt = now;
-        this.updatedAt = now;
-        
-        // Set time-based features
-        this.isWeekend = isWeekendTime(this.transactionTime);
-        this.isNightTime = isNightTime(this.transactionTime);
-    }
-    
-    @PreUpdate
-    protected void onUpdate() {
-        this.updatedAt = LocalDateTime.now();
-    }
-    
-    // Utility methods
-    private boolean isWeekendTime(LocalDateTime dateTime) {
-        int dayOfWeek = dateTime.getDayOfWeek().getValue();
-        return dayOfWeek == 6 || dayOfWeek == 7; // Saturday or Sunday
-    }
-    
-    private boolean isNightTime(LocalDateTime dateTime) {
-        int hour = dateTime.getHour();
-        return hour < 6 || hour > 22; // Between 10 PM and 6 AM
-    }
-    
-    public boolean isHighRisk() {
-        return fraudScore != null && fraudScore.compareTo(new BigDecimal("0.7")) > 0;
-    }
-    
-    public boolean isLargeAmount() {
-        return amount.compareTo(new BigDecimal("1000.00")) > 0;
-    }
-    
-    public boolean isFlagged() {
-        return status == TransactionStatus.FLAGGED;
-    }
-    
-    // Getters and Setters
-    public Long getId() { return id; }
-    public void setId(Long id) { this.id = id; }
-    
-    public User getUser() { return user; }
-    public void setUser(User user) { this.user = user; }
-    
-    public BigDecimal getAmount() { return amount; }
-    public void setAmount(BigDecimal amount) { this.amount = amount; }
-    
-    public String getMerchant() { return merchant; }
-    public void setMerchant(String merchant) { this.merchant = merchant; }
-    
-    public String getCategory() { return category; }
-    public void setCategory(String category) { this.category = category; }
-    
-    public String getLocation() { return location; }
-    public void setLocation(String location) { this.location = location; }
-    
-    public LocalDateTime getTransactionTime() { return transactionTime; }
-    public void setTransactionTime(LocalDateTime transactionTime) { this.transactionTime = transactionTime; }
-    
-    public TransactionStatus getStatus() { return status; }
-    public void setStatus(TransactionStatus status) { this.status = status; }
-    
-    public BigDecimal getFraudScore() { return fraudScore; }
-    public void setFraudScore(BigDecimal fraudScore) { this.fraudScore = fraudScore; }
-    
-    public String getTransactionType() { return transactionType; }
-    public void setTransactionType(String transactionType) { this.transactionType = transactionType; }
-    
-    public String getPaymentMethod() { return paymentMethod; }
-    public void setPaymentMethod(String paymentMethod) { this.paymentMethod = paymentMethod; }
-    
-    public String getCardLastFour() { return cardLastFour; }
-    public void setCardLastFour(String cardLastFour) { this.cardLastFour = cardLastFour; }
-    
-    public String getMerchantCategoryCode() { return merchantCategoryCode; }
-    public void setMerchantCategoryCode(String merchantCategoryCode) { this.merchantCategoryCode = merchantCategoryCode; }
-    
-    public String getCurrencyCode() { return currencyCode; }
-    public void setCurrencyCode(String currencyCode) { this.currencyCode = currencyCode; }
-    
-    public String getIpAddress() { return ipAddress; }
-    public void setIpAddress(String ipAddress) { this.ipAddress = ipAddress; }
-    
-    public String getDeviceFingerprint() { return deviceFingerprint; }
-    public void setDeviceFingerprint(String deviceFingerprint) { this.deviceFingerprint = deviceFingerprint; }
-    
-    public Double getLatitude() { return latitude; }
-    public void setLatitude(Double latitude) { this.latitude = latitude; }
-    
-    public Double getLongitude() { return longitude; }
-    public void setLongitude(Double longitude) { this.longitude = longitude; }
-    
-    public Boolean getIsWeekend() { return isWeekend; }
-    public void setIsWeekend(Boolean isWeekend) { this.isWeekend = isWeekend; }
-    
-    public Boolean getIsNightTime() { return isNightTime; }
-    public void setIsNightTime(Boolean isNightTime) { this.isNightTime = isNightTime; }
-    
-    public Integer getDaysSinceLastTransaction() { return daysSinceLastTransaction; }
-    public void setDaysSinceLastTransaction(Integer daysSinceLastTransaction) { this.daysSinceLastTransaction = daysSinceLastTransaction; }
-    
-    public Integer getVelocity1h() { return velocity1h; }
-    public void setVelocity1h(Integer velocity1h) { this.velocity1h = velocity1h; }
-    
-    public Integer getVelocity24h() { return velocity24h; }
-    public void setVelocity24h(Integer velocity24h) { this.velocity24h = velocity24h; }
-    
-    public Integer getVelocity7d() { return velocity7d; }
-    public void setVelocity7d(Integer velocity7d) { this.velocity7d = velocity7d; }
-    
-    public BigDecimal getAmount1h() { return amount1h; }
-    public void setAmount1h(BigDecimal amount1h) { this.amount1h = amount1h; }
-    
-    public BigDecimal getAmount24h() { return amount24h; }
-    public void setAmount24h(BigDecimal amount24h) { this.amount24h = amount24h; }
-    
-    public BigDecimal getAmount7d() { return amount7d; }
-    public void setAmount7d(BigDecimal amount7d) { this.amount7d = amount7d; }
-    
-    public LocalDateTime getCreatedAt() { return createdAt; }
-    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
-    
-    public LocalDateTime getUpdatedAt() { return updatedAt; }
-    public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }
-    
-    public LocalDateTime getProcessedAt() { return processedAt; }
-    public void setProcessedAt(LocalDateTime processedAt) { this.processedAt = processedAt; }
-    
-    public List<FraudAlert> getFraudAlerts() { return fraudAlerts; }
-    public void setFraudAlerts(List<FraudAlert> fraudAlerts) { this.fraudAlerts = fraudAlerts; }
-    
-    public List<TransactionFeature> getFeatures() { return features; }
-    public void setFeatures(List<TransactionFeature> features) { this.features = features; }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/TransactionFeature.java b/backend/src/main/java/com/fraudguard/model/TransactionFeature.java
deleted file mode 100644
index 1716221..0000000
--- a/backend/src/main/java/com/fraudguard/model/TransactionFeature.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package com.fraudguard.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "transaction_features", indexes = {
-    @Index(name = "idx_feature_transaction", columnList = "transaction_id"),
-    @Index(name = "idx_feature_name", columnList = "feature_name")
-})
-public class TransactionFeature {
-    
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "transaction_id", nullable = false)
-    private Transaction transaction;
-    
-    @Column(name = "feature_name", nullable = false, length = 100)
-    private String featureName;
-    
-    @Column(name = "feature_value", columnDefinition = "TEXT")
-    private String featureValue;
-    
-    @Column(name = "feature_type", length = 50)
-    private String featureType; // NUMERIC, CATEGORICAL, BOOLEAN
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-    
-    // Constructors
-    public TransactionFeature() {
-        this.createdAt = LocalDateTime.now();
-    }
-    
-    public TransactionFeature(Transaction transaction, String featureName, String featureValue, String featureType) {
-        this();
-        this.transaction = transaction;
-        this.featureName = featureName;
-        this.featureValue = featureValue;
-        this.featureType = featureType;
-    }
-    
-    // Getters and Setters
-    public Long getId() { return id; }
-    public void setId(Long id) { this.id = id; }
-    
-    public Transaction getTransaction() { return transaction; }
-    public void setTransaction(Transaction transaction) { this.transaction = transaction; }
-    
-    public String getFeatureName() { return featureName; }
-    public void setFeatureName(String featureName) { this.featureName = featureName; }
-    
-    public String getFeatureValue() { return featureValue; }
-    public void setFeatureValue(String featureValue) { this.featureValue = featureValue; }
-    
-    public String getFeatureType() { return featureType; }
-    public void setFeatureType(String featureType) { this.featureType = featureType; }
-    
-    public LocalDateTime getCreatedAt() { return createdAt; }
-    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/TransactionStatus.java b/backend/src/main/java/com/fraudguard/model/TransactionStatus.java
deleted file mode 100644
index 5864161..0000000
--- a/backend/src/main/java/com/fraudguard/model/TransactionStatus.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package com.fraudguard.model;
-
-public enum TransactionStatus {
-    PENDING("Transaction is being processed"),
-    APPROVED("Transaction approved"),
-    FLAGGED("Transaction flagged for review"),
-    REJECTED("Transaction rejected"),
-    UNDER_REVIEW("Transaction under manual review"),
-    CANCELLED("Transaction cancelled"),
-    TIMEOUT("Transaction timed out"),
-    FAILED("Transaction failed");
-    
-    private final String description;
-    
-    TransactionStatus(String description) {
-        this.description = description;
-    }
-    
-    public String getDescription() {
-        return description;
-    }
-    
-    public boolean isCompleted() {
-        return this == APPROVED || this == REJECTED || this == CANCELLED;
-    }
-    
-    public boolean requiresReview() {
-        return this == FLAGGED || this == UNDER_REVIEW;
-    }
-    
-    public boolean isPending() {
-        return this == PENDING;
-    }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/TransactionType.java b/backend/src/main/java/com/fraudguard/model/TransactionType.java
deleted file mode 100644
index 93e5b95..0000000
--- a/backend/src/main/java/com/fraudguard/model/TransactionType.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package com.fraudguard.model;
-
-public enum TransactionType {
-    PURCHASE, WITHDRAWAL, TRANSFER, DEPOSIT, REFUND
-}
diff --git a/backend/src/main/java/com/fraudguard/model/User.java b/backend/src/main/java/com/fraudguard/model/User.java
index fada23a..038b31a 100644
--- a/backend/src/main/java/com/fraudguard/model/User.java
+++ b/backend/src/main/java/com/fraudguard/model/User.java
@@ -1,96 +1,45 @@
+
 package com.fraudguard.model;
 
 import jakarta.persistence.*;
-import jakarta.validation.constraints.Email;
-import jakarta.validation.constraints.NotBlank;
-import jakarta.validation.constraints.Size;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.List;
+import lombok.*;
 
 @Entity
-@Table(name = "users", indexes = {
-    @Index(name = "idx_user_email", columnList = "email"),
-    @Index(name = "idx_user_created", columnList = "created_at")
-})
+@Table(name = "users")
+@Getter @Setter @NoArgsConstructor @AllArgsConstructor @Builder
 public class User {
-
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
 
-    @NotBlank(message = "Email is required")
-    @Email(message = "Invalid email format")
-    @Column(unique = true, nullable = false, length = 255)
-    private String email;
-
-    @NotBlank(message = "First name is required")
-    @Size(min = 1, max = 100, message = "First name must be between 1 and 100 characters")
-    @Column(name = "first_name", nullable = false, length = 100)
-    private String firstName;
-
-    @NotBlank(message = "Last name is required")
-    @Size(min = 1, max = 100, message = "Last name must be between 1 and 100 characters")
-    @Column(name = "last_name", nullable = false, length = 100)
-    private String lastName;
-
-    @Column(name = "phone_number", length = 20)
-    private String phoneNumber;
-
-    @Column(name = "date_of_birth")
-    private LocalDateTime dateOfBirth;
-
-    @Column(name = "address", columnDefinition = "TEXT")
-    private String address;
-
-    @Column(name = "city", length = 100)
-    private String city;
+    @Column(unique = true, nullable = false)
+    private String username;
 
-    @Column(name = "country", length = 100)
-    private String country;
-
-    @Column(name = "postal_code", length = 20)
-    private String postalCode;
-
-    @Enumerated(EnumType.STRING)
-    @Column(name = "account_status")
-    private AccountStatus accountStatus = AccountStatus.ACTIVE;
-
-    @Column(name = "risk_score", precision = 3, scale = 2)
-    private Double riskScore = 0.0;
-
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-
-    @Column(name = "updated_at", nullable = false)
-    private LocalDateTime updatedAt;
+    @Column(unique = true, nullable = false)
+    private String email;
 
-    @Column(name = "last_login")
-    private LocalDateTime lastLogin;
+    @Column(nullable = false)
+    private String password;
 
-    @JsonIgnore
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    private List<Transaction> transactions = new ArrayList<>();
+    private String role; // ADMIN/ANALYST
 
-    @JsonIgnore
-    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
-    private List<UserSession> sessions = new ArrayList<>();
+    public CharSequence getPassword() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
 
-    // Constructors
-    public User() {
-        this.createdAt = LocalDateTime.now();
-        this.updatedAt = LocalDateTime.now();
+    public void setRole(String analyst) {
+        throw new UnsupportedOperationException("Not supported yet.");
     }
 
-    public User(String email, String firstName, String lastName) {
-        this();
-        this.email = email;
-        this.firstName = firstName;
-        this.lastName = lastName;
+    public Object getRole() {
+        throw new UnsupportedOperationException("Not supported yet.");
     }
 
-    // Getters and setters (recommended)
-    // ... add them as needed
+    public void setPassword(String encode) {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
 
+    public String getUsername() {
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
 }
diff --git a/backend/src/main/java/com/fraudguard/model/UserBehavior.java b/backend/src/main/java/com/fraudguard/model/UserBehavior.java
deleted file mode 100644
index f02fe27..0000000
--- a/backend/src/main/java/com/fraudguard/model/UserBehavior.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package com.fraudguard.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "user_behaviors")
-public class UserBehavior {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    private User user;
-    
-    @Column(name = "behavior_type")
-    private String behaviorType;
-    
-    @Column(name = "behavior_value")
-    private String behaviorValue;
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt = LocalDateTime.now();
-    
-    public UserBehavior() {}
-    
-    public Long getId() { return id; }
-    public void setId(Long id) { this.id = id; }
-    
-    public User getUser() { return user; }
-    public void setUser(User user) { this.user = user; }
-}
diff --git a/backend/src/main/java/com/fraudguard/model/UserSession.java b/backend/src/main/java/com/fraudguard/model/UserSession.java
deleted file mode 100644
index 8ae233d..0000000
--- a/backend/src/main/java/com/fraudguard/model/UserSession.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package com.fraudguard.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "user_sessions")
-public class UserSession {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    private User user;
-    
-    @Column(name = "session_token", unique = true, nullable = false)
-    private String sessionToken;
-    
-    @Column(name = "ip_address")
-    private String ipAddress;
-    
-    @Column(name = "user_agent")
-    private String userAgent;
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "expires_at", nullable = false)
-    private LocalDateTime expiresAt;
-    
-    @Column(name = "is_active")
-    private Boolean isActive = true;
-    
-    // Constructor
-    public UserSession() {
-        this.createdAt = LocalDateTime.now();
-    }
-    
-    // All getters and setters for each field...
-}
diff --git a/backend/src/main/java/com/fraudguard/model/UserSession.java.backup b/backend/src/main/java/com/fraudguard/model/UserSession.java.backup
deleted file mode 100644
index 494ecb8..0000000
--- a/backend/src/main/java/com/fraudguard/model/UserSession.java.backup
+++ /dev/null
@@ -1,86 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.model.User;
-import com.fraudguard.model.AccountStatus;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Optional;
-
-@Repository
-public interface UserRepository extends JpaRepository<User, Long> {
-    
-    // Basic queries
-    Optional<User> findByEmail(String email);
-    
-    boolean existsByEmail(String email);
-    
-    List<User> findByAccountStatus(AccountStatus accountStatus);
-    
-    // Risk-based queries
-    @Query("SELECT u FROM User u WHERE u.riskScore > :threshold")
-    List<User> findHighRiskUsers(@Param("threshold") Double threshold);
-    
-    @Query("SELECT u FROM User u WHERE u.riskScore BETWEEN :minScore AND :maxScore")
-    List<User> findUsersByRiskScoreRange(@Param("minScore") Double minScore, 
-                                        @Param("maxScore") Double maxScore);
-    
-    // Location-based queries
-    List<User> findByCity(String city);
-    
-    List<User> findByCountry(String country);
-    
-    @Query("SELECT u FROM User u WHERE u.city = :city AND u.country = :country")
-    List<User> findByLocation(@Param("city") String city, @Param("country") String country);
-    
-    // Time-based queries
-    @Query("SELECT u FROM User u WHERE u.createdAt BETWEEN :startDate AND :endDate")
-    List<User> findUsersCreatedBetween(@Param("startDate") LocalDateTime startDate, 
-                                      @Param("endDate") LocalDateTime endDate);
-    
-    @Query("SELECT u FROM User u WHERE u.lastLogin < :dateTime")
-    List<User> findInactiveUsersSince(@Param("dateTime") LocalDateTime dateTime);
-    
-    // Search queries
-    @Query("SELECT u FROM User u WHERE " +
-           "LOWER(u.firstName) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR " +
-           "LOWER(u.lastName) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR " +
-           "LOWER(u.email) LIKE LOWER(CONCAT('%', :searchTerm, '%'))")
-    List<User> searchUsers(@Param("searchTerm") String searchTerm);
-    
-    // Statistical queries
-    @Query("SELECT COUNT(u) FROM User u WHERE u.accountStatus = :status")
-    Long countByAccountStatus(@Param("status") AccountStatus status);
-    
-    @Query("SELECT AVG(u.riskScore) FROM User u WHERE u.accountStatus = 'ACTIVE'")
-    Double getAverageRiskScore();
-    
-    @Query("SELECT u.country, COUNT(u) FROM User u GROUP BY u.country ORDER BY COUNT(u) DESC")
-    List<Object[]> getUserCountByCountry();
-    
-    // Complex fraud-related queries
-    @Query("SELECT u FROM User u WHERE u.id IN " +
-           "(SELECT t.user.id FROM Transaction t WHERE t.status = 'FLAGGED' " +
-           "GROUP BY t.user.id HAVING COUNT(t) > :threshold)")
-    List<User> findUsersWithMultipleFlaggedTransactions(@Param("threshold") Integer threshold);
-    
-    @Query("SELECT u FROM User u JOIN u.transactions t " +
-           "WHERE t.fraudScore > :fraudScore AND t.createdAt > :since")
-    List<User> findUsersWithRecentHighRiskTransactions(@Param("fraudScore") Double fraudScore, 
-                                                      @Param("since") LocalDateTime since);
-    
-    // Update queries
-    @Query("UPDATE User u SET u.riskScore = :riskScore, u.updatedAt = CURRENT_TIMESTAMP " +
-           "WHERE u.id = :userId")
-    void updateUserRiskScore(@Param("userId") Long userId, @Param("riskScore") Double riskScore);
-    
-    @Query("UPDATE User u SET u.lastLogin = CURRENT_TIMESTAMP WHERE u.id = :userId")
-    void updateLastLogin(@Param("userId") Long userId);
-    
-    @Query("UPDATE User u SET u.accountStatus = :status WHERE u.id = :userId")
-    void updateAccountStatus(@Param("userId") Long userId, @Param("status") AccountStatus status);
-}
diff --git a/backend/src/main/java/com/fraudguard/repository/AlertRepository.java b/backend/src/main/java/com/fraudguard/repository/AlertRepository.java
new file mode 100644
index 0000000..ebd1db7
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/repository/AlertRepository.java
@@ -0,0 +1,7 @@
+
+package com.fraudguard.repository;
+
+import com.fraudguard.model.Alert;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface AlertRepository extends JpaRepository<Alert, Long> { }
diff --git a/backend/src/main/java/com/fraudguard/repository/CustomerRepository.java b/backend/src/main/java/com/fraudguard/repository/CustomerRepository.java
new file mode 100644
index 0000000..76043bc
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/repository/CustomerRepository.java
@@ -0,0 +1,7 @@
+
+package com.fraudguard.repository;
+
+import com.fraudguard.model.Customer;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface CustomerRepository extends JpaRepository<Customer, Long> { }
diff --git a/backend/src/main/java/com/fraudguard/repository/FraudAlertRepository.java b/backend/src/main/java/com/fraudguard/repository/FraudAlertRepository.java
deleted file mode 100644
index 02ea485..0000000
--- a/backend/src/main/java/com/fraudguard/repository/FraudAlertRepository.java
+++ /dev/null
@@ -1,176 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.model.FraudAlert;
-import com.fraudguard.model.AlertSeverity;
-import com.fraudguard.model.AlertStatus;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Optional;
-
-@Repository
-public interface FraudAlertRepository extends JpaRepository<FraudAlert, Long> {
-    
-    // Basic queries
-    Optional<FraudAlert> findByAlertId(String alertId);
-    
-    List<FraudAlert> findByStatus(AlertStatus status);
-    
-    List<FraudAlert> findBySeverity(AlertSeverity severity);
-    
-    List<FraudAlert> findByAlertType(String alertType);
-    
-    // Transaction-based queries
-    List<FraudAlert> findByTransactionId(Long transactionId);
-    
-    List<FraudAlert> findByTransactionTransactionId(String transactionId);
-    
-    // User-based queries
-    List<FraudAlert> findByUserId(Long userId);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.user.id = :userId " +
-           "AND fa.createdAt > :since ORDER BY fa.createdAt DESC")
-    List<FraudAlert> findRecentAlertsByUser(@Param("userId") Long userId, 
-                                          @Param("since") LocalDateTime since);
-    
-    // Status-based queries
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.status = 'OPEN' ORDER BY fa.severity DESC, fa.createdAt")
-    List<FraudAlert> findOpenAlertsOrderBySeverity();
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.status IN ('OPEN', 'IN_PROGRESS') " +
-           "ORDER BY fa.severity DESC, fa.createdAt")
-    List<FraudAlert> findActiveAlerts();
-    
-    Page<FraudAlert> findByStatusOrderByCreatedAtDesc(AlertStatus status, Pageable pageable);
-    
-    // Severity-based queries
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.severity IN ('HIGH', 'CRITICAL') " +
-           "AND fa.status = 'OPEN'")
-    List<FraudAlert> findCriticalOpenAlerts();
-    
-    List<FraudAlert> findBySeverityAndStatusOrderByCreatedAtDesc(AlertSeverity severity, AlertStatus status);
-    
-    // Time-based queries
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.createdAt BETWEEN :start AND :end")
-    List<FraudAlert> findAlertsBetween(@Param("start") LocalDateTime start, 
-                                     @Param("end") LocalDateTime end);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.createdAt > :since ORDER BY fa.createdAt DESC")
-    List<FraudAlert> findRecentAlerts(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.status = 'OPEN' " +
-           "AND fa.createdAt < :threshold ORDER BY fa.createdAt")
-    List<FraudAlert> findStaleAlerts(@Param("threshold") LocalDateTime threshold);
-    
-    // Confidence score queries
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.confidenceScore > :threshold")
-    List<FraudAlert> findHighConfidenceAlerts(@Param("threshold") BigDecimal threshold);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.confidenceScore BETWEEN :min AND :max")
-    List<FraudAlert> findAlertsByConfidenceRange(@Param("min") BigDecimal min, 
-                                               @Param("max") BigDecimal max);
-    
-    // Model-based queries
-    List<FraudAlert> findByModelName(String modelName);
-    
-    List<FraudAlert> findByRuleTriggered(String ruleTriggered);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.modelName = :modelName " +
-           "AND fa.modelVersion = :version")
-    List<FraudAlert> findByModelAndVersion(@Param("modelName") String modelName, 
-                                         @Param("version") String version);
-    
-    // False positive queries
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.falsePositive = true")
-    List<FraudAlert> findFalsePositives();
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.falsePositive = false " +
-           "AND fa.status = 'RESOLVED'")
-    List<FraudAlert> findValidResolvedAlerts();
-    
-    // Analyst queries
-    List<FraudAlert> findByResolvedBy(String resolvedBy);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.resolvedBy = :analyst " +
-           "AND fa.resolvedAt BETWEEN :start AND :end")
-    List<FraudAlert> findAlertsResolvedByAnalyst(@Param("analyst") String analyst,
-                                               @Param("start") LocalDateTime start,
-                                               @Param("end") LocalDateTime end);
-    
-    // Statistical queries
-    @Query("SELECT fa.status, COUNT(fa) FROM FraudAlert fa GROUP BY fa.status")
-    List<Object[]> getAlertCountsByStatus();
-    
-    @Query("SELECT fa.severity, COUNT(fa) FROM FraudAlert fa WHERE fa.createdAt > :since " +
-           "GROUP BY fa.severity ORDER BY fa.severity")
-    List<Object[]> getAlertCountsBySeverity(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT fa.alertType, COUNT(fa) FROM FraudAlert fa WHERE fa.createdAt > :since " +
-           "GROUP BY fa.alertType ORDER BY COUNT(fa) DESC")
-    List<Object[]> getAlertCountsByType(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT COUNT(fa) FROM FraudAlert fa WHERE fa.createdAt > :since " +
-           "AND fa.falsePositive = false")
-    Long countValidAlertsSince(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT COUNT(fa) FROM FraudAlert fa WHERE fa.createdAt > :since " +
-           "AND fa.falsePositive = true")
-    Long countFalsePositivesSince(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT AVG(fa.confidenceScore) FROM FraudAlert fa WHERE fa.falsePositive = false")
-    BigDecimal getAverageConfidenceScoreForValidAlerts();
-    
-    // Performance queries
-    @Query("SELECT fa.resolvedBy, COUNT(fa), AVG(TIMESTAMPDIFF(HOUR, fa.createdAt, fa.resolvedAt)) " +
-           "FROM FraudAlert fa WHERE fa.resolvedAt IS NOT NULL " +
-           "AND fa.resolvedAt > :since GROUP BY fa.resolvedBy")
-    List<Object[]> getAnalystPerformanceMetrics(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT AVG(TIMESTAMPDIFF(HOUR, fa.createdAt, fa.resolvedAt)) " +
-           "FROM FraudAlert fa WHERE fa.resolvedAt IS NOT NULL " +
-           "AND fa.severity = :severity")
-    Double getAverageResolutionTimeForSeverity(@Param("severity") AlertSeverity severity);
-    
-    // Search queries
-    @Query("SELECT fa FROM FraudAlert fa WHERE " +
-           "LOWER(fa.reason) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR " +
-           "LOWER(fa.alertType) LIKE LOWER(CONCAT('%', :searchTerm, '%')) OR " +
-           "LOWER(fa.analystNotes) LIKE LOWER(CONCAT('%', :searchTerm, '%'))")
-    List<FraudAlert> searchAlerts(@Param("searchTerm") String searchTerm);
-    
-    // Complex queries
-    @Query("SELECT fa FROM FraudAlert fa JOIN fa.transaction t " +
-           "WHERE t.amount > :minAmount AND fa.severity = :severity " +
-           "AND fa.status = 'OPEN'")
-    List<FraudAlert> findHighValueAlertsWithSeverity(@Param("minAmount") BigDecimal minAmount,
-                                                    @Param("severity") AlertSeverity severity);
-    
-    @Query("SELECT fa FROM FraudAlert fa WHERE fa.transaction.user.id = :userId " +
-           "AND fa.createdAt > :since AND fa.status != 'FALSE_POSITIVE' " +
-           "ORDER BY fa.createdAt DESC")
-    List<FraudAlert> findValidAlertsForUser(@Param("userId") Long userId, 
-                                          @Param("since") LocalDateTime since);
-    
-    // Update queries
-    @Query("UPDATE FraudAlert fa SET fa.status = :status, fa.updatedAt = CURRENT_TIMESTAMP " +
-           "WHERE fa.id = :alertId")
-    void updateAlertStatus(@Param("alertId") Long alertId, @Param("status") AlertStatus status);
-    
-    @Query("UPDATE FraudAlert fa SET fa.status = :status, fa.resolvedBy = :resolvedBy, " +
-           "fa.resolvedAt = CURRENT_TIMESTAMP, fa.analystNotes = :notes, " +
-           "fa.updatedAt = CURRENT_TIMESTAMP WHERE fa.id = :alertId")
-    void resolveAlert(@Param("alertId") Long alertId, @Param("status") AlertStatus status,
-                     @Param("resolvedBy") String resolvedBy, @Param("notes") String notes);
-    
-    @Query("UPDATE FraudAlert fa SET fa.falsePositive = true, fa.status = 'FALSE_POSITIVE', " +
-           "fa.resolvedBy = :resolvedBy, fa.resolvedAt = CURRENT_TIMESTAMP, " +
-           "fa.updatedAt = CURRENT_TIMESTAMP WHERE fa.id = :alertId")
-    void markAsFalsePositive(@Param("alertId") Long alertId, @Param("resolvedBy") String resolvedBy);
-}
diff --git a/backend/src/main/java/com/fraudguard/repository/SarRepository.java b/backend/src/main/java/com/fraudguard/repository/SarRepository.java
new file mode 100644
index 0000000..e06b797
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/repository/SarRepository.java
@@ -0,0 +1,7 @@
+
+package com.fraudguard.repository;
+
+import com.fraudguard.model.Sar;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface SarRepository extends JpaRepository<Sar, Long> { }
diff --git a/backend/src/main/java/com/fraudguard/repository/TransactionFeatureRepository.java b/backend/src/main/java/com/fraudguard/repository/TransactionFeatureRepository.java
deleted file mode 100644
index cada83d..0000000
--- a/backend/src/main/java/com/fraudguard/repository/TransactionFeatureRepository.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.model.TransactionFeature;
-import com.fraudguard.model.FeatureType;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-
-import java.math.BigDecimal;
-import java.util.List;
-
-@Repository
-public interface TransactionFeatureRepository extends JpaRepository<TransactionFeature, Long> {
-    
-    // Basic queries
-    List<TransactionFeature> findByTransactionId(Long transactionId);
-    
-    List<TransactionFeature> findByFeatureName(String featureName);
-    
-    List<TransactionFeature> findByFeatureType(FeatureType featureType);
-    
-    // Feature value queries
-    @Query("SELECT tf FROM TransactionFeature tf WHERE tf.featureName = :featureName " +
-           "AND tf.featureValue > :threshold")
-    List<TransactionFeature> findFeaturesAboveThreshold(@Param("featureName") String featureName,
-                                                       @Param("threshold") BigDecimal threshold);
-    
-    // Importance queries
-    @Query("SELECT tf FROM TransactionFeature tf WHERE tf.importanceScore > :threshold " +
-           "ORDER BY tf.importanceScore DESC")
-    List<TransactionFeature> findHighImportanceFeatures(@Param("threshold") BigDecimal threshold);
-    
-    // Statistical queries
-    @Query("SELECT tf.featureName, AVG(tf.featureValue), MAX(tf.featureValue), MIN(tf.featureValue) " +
-           "FROM TransactionFeature tf WHERE tf.featureType = 'NUMERIC' " +
-           "GROUP BY tf.featureName")
-    List<Object[]> getNumericFeatureStatistics();
-    
-    @Query("SELECT tf.featureName, COUNT(tf) FROM TransactionFeature tf " +
-           "GROUP BY tf.featureName ORDER BY COUNT(tf) DESC")
-    List<Object[]> getFeatureUsageStatistics();
-}
diff --git a/backend/src/main/java/com/fraudguard/repository/TransactionRepository.java b/backend/src/main/java/com/fraudguard/repository/TransactionRepository.java
deleted file mode 100644
index 8c1fcdc..0000000
--- a/backend/src/main/java/com/fraudguard/repository/TransactionRepository.java
+++ /dev/null
@@ -1,165 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.model.Transaction;
-import com.fraudguard.model.TransactionStatus;
-import com.fraudguard.model.TransactionType;
-import com.fraudguard.model.PaymentMethod;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Optional;
-
-@Repository
-public interface TransactionRepository extends JpaRepository<Transaction, Long> {
-    
-    // Basic queries
-    Optional<Transaction> findByTransactionId(String transactionId);
-    
-    List<Transaction> findByUserIdOrderByTransactionTimeDesc(Long userId);
-    
-    Page<Transaction> findByUserIdOrderByTransactionTimeDesc(Long userId, Pageable pageable);
-    
-    List<Transaction> findByStatus(TransactionStatus status);
-    
-    List<Transaction> findByTransactionType(TransactionType transactionType);
-    
-    List<Transaction> findByPaymentMethod(PaymentMethod paymentMethod);
-    
-    // Amount-based queries
-    @Query("SELECT t FROM Transaction t WHERE t.amount > :amount")
-    List<Transaction> findLargeTransactions(@Param("amount") BigDecimal amount);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.amount BETWEEN :minAmount AND :maxAmount")
-    List<Transaction> findTransactionsByAmountRange(@Param("minAmount") BigDecimal minAmount, 
-                                                   @Param("maxAmount") BigDecimal maxAmount);
-    
-    // Time-based queries
-    @Query("SELECT t FROM Transaction t WHERE t.transactionTime BETWEEN :start AND :end")
-    List<Transaction> findTransactionsBetween(@Param("start") LocalDateTime start, 
-                                            @Param("end") LocalDateTime end);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.transactionTime > :since ORDER BY t.transactionTime DESC")
-    List<Transaction> findRecentTransactions(@Param("since") LocalDateTime since);
-    
-    // Fraud-related queries
-    @Query("SELECT t FROM Transaction t WHERE t.fraudScore > :threshold")
-    List<Transaction> findHighRiskTransactions(@Param("threshold") BigDecimal threshold);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.isFraud = true")
-    List<Transaction> findFraudulentTransactions();
-    
-    @Query("SELECT t FROM Transaction t WHERE t.status = 'FLAGGED' ORDER BY t.fraudScore DESC")
-    List<Transaction> findFlaggedTransactionsOrderByRisk();
-    
-    // Merchant-based queries
-    List<Transaction> findByMerchant(String merchant);
-    
-    List<Transaction> findByMerchantCategory(String merchantCategory);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.merchant LIKE %:merchantName%")
-    List<Transaction> findTransactionsByMerchantPattern(@Param("merchantName") String merchantName);
-    
-    // Location-based queries
-    List<Transaction> findByLocation(String location);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.latitude BETWEEN :minLat AND :maxLat " +
-           "AND t.longitude BETWEEN :minLon AND :maxLon")
-    List<Transaction> findTransactionsInArea(@Param("minLat") Double minLat, @Param("maxLat") Double maxLat,
-                                           @Param("minLon") Double minLon, @Param("maxLon") Double maxLon);
-    
-    // User behavior queries
-    @Query("SELECT COUNT(t) FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.transactionTime > :since")
-    Long countUserTransactionsSince(@Param("userId") Long userId, @Param("since") LocalDateTime since);
-    
-    @Query("SELECT SUM(t.amount) FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.transactionTime > :since AND t.status = 'APPROVED'")
-    BigDecimal sumUserTransactionAmountSince(@Param("userId") Long userId, @Param("since") LocalDateTime since);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.transactionTime BETWEEN :start AND :end " +
-           "ORDER BY t.transactionTime DESC")
-    List<Transaction> findUserTransactionsInPeriod(@Param("userId") Long userId,
-                                                  @Param("start") LocalDateTime start,
-                                                  @Param("end") LocalDateTime end);
-    
-    // Velocity checks
-    @Query("SELECT COUNT(t) FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.transactionTime > :since AND t.amount > :minAmount")
-    Long countUserLargeTransactionsSince(@Param("userId") Long userId, 
-                                        @Param("since") LocalDateTime since,
-                                        @Param("minAmount") BigDecimal minAmount);
-    
-    @Query("SELECT COUNT(t) FROM Transaction t WHERE t.ipAddress = :ipAddress " +
-           "AND t.transactionTime > :since")
-    Long countTransactionsByIpSince(@Param("ipAddress") String ipAddress, @Param("since") LocalDateTime since);
-    
-    @Query("SELECT COUNT(t) FROM Transaction t WHERE t.deviceId = :deviceId " +
-           "AND t.transactionTime > :since")
-    Long countTransactionsByDeviceSince(@Param("deviceId") String deviceId, @Param("since") LocalDateTime since);
-    
-    // Statistical queries
-    @Query("SELECT AVG(t.amount) FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.status = 'APPROVED' AND t.transactionTime > :since")
-    BigDecimal getAverageTransactionAmountForUser(@Param("userId") Long userId, 
-                                                 @Param("since") LocalDateTime since);
-    
-    @Query("SELECT MAX(t.amount) FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.status = 'APPROVED'")
-    BigDecimal getMaxTransactionAmountForUser(@Param("userId") Long userId);
-    
-    @Query("SELECT t.merchant, COUNT(t), SUM(t.amount) FROM Transaction t " +
-           "WHERE t.transactionTime > :since GROUP BY t.merchant ORDER BY COUNT(t) DESC")
-    List<Object[]> getMerchantStatistics(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT t.status, COUNT(t) FROM Transaction t " +
-           "WHERE t.transactionTime > :since GROUP BY t.status")
-    List<Object[]> getTransactionStatusCounts(@Param("since") LocalDateTime since);
-    
-    // Pattern detection queries
-    @Query("SELECT t FROM Transaction t WHERE t.user.id = :userId " +
-           "AND t.merchant = :merchant AND t.transactionTime > :since " +
-           "ORDER BY t.transactionTime DESC")
-    List<Transaction> findRepeatedMerchantTransactions(@Param("userId") Long userId,
-                                                     @Param("merchant") String merchant,
-                                                     @Param("since") LocalDateTime since);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.amount = :amount " +
-           "AND t.transactionTime BETWEEN :start AND :end")
-    List<Transaction> findTransactionsByExactAmount(@Param("amount") BigDecimal amount,
-                                                   @Param("start") LocalDateTime start,
-                                                   @Param("end") LocalDateTime end);
-    
-    // Real-time monitoring queries
-    @Query("SELECT t FROM Transaction t WHERE t.status = 'PENDING' " +
-           "AND t.createdAt < :timeThreshold ORDER BY t.createdAt")
-    List<Transaction> findStuckTransactions(@Param("timeThreshold") LocalDateTime timeThreshold);
-    
-    @Query("SELECT t FROM Transaction t WHERE t.fraudScore > :threshold " +
-           "AND t.status = 'PENDING' ORDER BY t.fraudScore DESC, t.createdAt")
-    List<Transaction> findPendingHighRiskTransactions(@Param("threshold") BigDecimal threshold);
-    
-    // Update queries
-    @Query("UPDATE Transaction t SET t.status = :status, t.updatedAt = CURRENT_TIMESTAMP " +
-           "WHERE t.id = :transactionId")
-    void updateTransactionStatus(@Param("transactionId") Long transactionId, 
-                                @Param("status") TransactionStatus status);
-    
-    @Query("UPDATE Transaction t SET t.fraudScore = :fraudScore, t.updatedAt = CURRENT_TIMESTAMP " +
-           "WHERE t.id = :transactionId")
-    void updateFraudScore(@Param("transactionId") Long transactionId, 
-                         @Param("fraudScore") BigDecimal fraudScore);
-    
-    @Query("UPDATE Transaction t SET t.isFraud = :isFraud, t.fraudReason = :reason, " +
-           "t.updatedAt = CURRENT_TIMESTAMP WHERE t.id = :transactionId")
-    void markAsFraud(@Param("transactionId") Long transactionId, 
-                     @Param("isFraud") Boolean isFraud, 
-                     @Param("reason") String reason);
-}
diff --git a/backend/src/main/java/com/fraudguard/repository/UserBehaviorRepository.java b/backend/src/main/java/com/fraudguard/repository/UserBehaviorRepository.java
deleted file mode 100644
index e0a48eb..0000000
--- a/backend/src/main/java/com/fraudguard/repository/UserBehaviorRepository.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.model.UserBehavior;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Optional;
-
-@Repository
-public interface UserBehaviorRepository extends JpaRepository<UserBehavior, Long> {
-    
-    // Basic queries
-    List<UserBehavior> findByUserId(Long userId);
-    
-    Optional<UserBehavior> findByUserIdAndBehaviorType(Long userId, String behaviorType);
-    
-    List<UserBehavior> findByBehaviorType(String behaviorType);
-    
-    // Latest behavior queries
-    @Query("SELECT ub FROM UserBehavior ub WHERE ub.user.id = :userId " +
-           "ORDER BY ub.updatedAt DESC")
-    List<UserBehavior> findLatestUserBehavior(@Param("userId") Long userId);
-    
-    @Query("SELECT ub FROM UserBehavior ub WHERE ub.user.id = :userId " +
-           "AND ub.behaviorType = :behaviorType ORDER BY ub.updatedAt DESC")
-    Optional<UserBehavior> findLatestUserBehaviorByType(@Param("userId") Long userId, 
-                                                       @Param("behaviorType") String behaviorType);
-    
-    // Risk-based queries
-    @Query("SELECT ub FROM UserBehavior ub WHERE ub.riskScore > :threshold")
-    List<UserBehavior> findHighRiskBehaviors(@Param("threshold") BigDecimal threshold);
-    
-    @Query("SELECT ub FROM UserBehavior ub WHERE ub.riskScore BETWEEN :minScore AND :maxScore")
-    List<UserBehavior> findBehaviorsByRiskRange(@Param("minScore") BigDecimal minScore, 
-                                              @Param("maxScore") BigDecimal maxScore);
-    
-    // Time-based queries
-    @Query("SELECT ub FROM UserBehavior ub WHERE ub.createdAt > :since")
-    List<UserBehavior> findRecentBehaviorUpdates(@Param("since") LocalDateTime since);
-    
-    @Query("SELECT ub FROM UserBehavior ub WHERE ub.analysisPeriodStart >= :startDate " +
-           "AND ub.analysisPeriodEnd <= :endDate")
-    List<UserBehavior> findBehaviorsByAnalysisPeriod(@Param("startDate") LocalDateTime startDate,
-                                                    @Param("endDate") LocalDateTime endDate);
-    
-    // Statistical queries
-    @Query("SELECT AVG(ub.avgTransactionAmount) FROM UserBehavior ub " +
-           "WHERE ub.behaviorType = :behaviorType")
-    BigDecimal getAverageTransactionAmountByType(@Param("behaviorType") String behaviorType);
-    
-    @Query("SELECT ub.behaviorType, COUNT(ub), AVG(ub.riskScore) FROM UserBehavior ub " +
-           "GROUP BY ub.behaviorType")
-    List<Object[]> getBehaviorStatistics();
-    
-    // Update queries
-    @Query("UPDATE UserBehavior ub SET ub.riskScore = :riskScore, " +
-           "ub.updatedAt = CURRENT_TIMESTAMP WHERE ub.id = :behaviorId")
-    void updateRiskScore(@Param("behaviorId") Long behaviorId, 
-                        @Param("riskScore") BigDecimal riskScore);
-}
diff --git a/backend/src/main/java/com/fraudguard/repository/UserRepository.java b/backend/src/main/java/com/fraudguard/repository/UserRepository.java
index 0a13dc3..dda5be8 100644
--- a/backend/src/main/java/com/fraudguard/repository/UserRepository.java
+++ b/backend/src/main/java/com/fraudguard/repository/UserRepository.java
@@ -1,48 +1,11 @@
+
 package com.fraudguard.repository;
 
 import com.fraudguard.model.User;
-import com.fraudguard.model.AccountStatus;
 import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
 
-import java.time.LocalDateTime;
-import java.util.List;
 import java.util.Optional;
 
-@Repository
 public interface UserRepository extends JpaRepository<User, Long> {
-    
-    // Basic queries
-    Optional<User> findByEmail(String email);
-    
-    boolean existsByEmail(String email);
-    
-    List<User> findByAccountStatus(AccountStatus accountStatus);
-    
-    // Risk-based queries
-    @Query("SELECT u FROM User u WHERE u.riskScore > :threshold")
-    List<User> findHighRiskUsers(@Param("threshold") Double threshold);
-    
-    @Query("SELECT u FROM User u WHERE u.riskScore BETWEEN :minScore AND :maxScore")
-    List<User> findUsersByRiskScoreRange(@Param("minScore") Double minScore, 
-                                        @Param("maxScore") Double maxScore);
-    
-    // Location-based queries
-    List<User> findByCity(String city);
-    
-    List<User> findByCountry(String country);
-    
-    @Query("SELECT u FROM User u WHERE u.city = :city AND u.country = :country")
-    List<User> findByLocation(@Param("city") String city, @Param("country") String country);
-    
-    // Time-based queries
-    @Query("SELECT u FROM User u WHERE u.createdAt BETWEEN :startDate AND :endDate")
-    List<User> findUsersCreatedBetween(@Param("startDate") LocalDateTime startDate, 
-                                      @Param("endDate") LocalDateTime endDate);
-    
-    @Query("SELECT u FROM User u WHERE u.lastLogin < :date")
-    List<User> findUsersWithLastLoginBefore(@Param("date") LocalDateTime date);
+    Optional<User> findByUsername(String username);
 }
-
diff --git a/backend/src/main/java/com/fraudguard/security/JwtAuthFilter.java b/backend/src/main/java/com/fraudguard/security/JwtAuthFilter.java
new file mode 100644
index 0000000..d6ad9fb
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/security/JwtAuthFilter.java
@@ -0,0 +1,50 @@
+package com.fraudguard.security;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+// REMOVE @Component annotation - this is the key change
+public class JwtAuthFilter extends OncePerRequestFilter {
+
+    private final JwtService jwtService;
+    private final UserDetailsService userDetailsService;
+
+    public JwtAuthFilter(JwtService jwtService, UserDetailsService userDetailsService) {
+        this.jwtService = jwtService;
+        this.userDetailsService = userDetailsService;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
+            throws ServletException, IOException {
+        // Your existing filter logic remains the same
+        final String authHeader = request.getHeader("Authorization");
+        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
+            filterChain.doFilter(request, response);
+            return;
+        }
+
+        String token = authHeader.substring(7);
+        if (jwtService.isTokenValid(token)) {
+            String username = jwtService.extractUsername(token);
+            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
+                UsernamePasswordAuthenticationToken authToken =
+                        new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
+                authToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
+                SecurityContextHolder.getContext().setAuthentication(authToken);
+            }
+        }
+        filterChain.doFilter(request, response);
+    }
+}
\ No newline at end of file
diff --git a/backend/src/main/java/com/fraudguard/security/JwtService.java b/backend/src/main/java/com/fraudguard/security/JwtService.java
new file mode 100644
index 0000000..62557dc
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/security/JwtService.java
@@ -0,0 +1,40 @@
+
+package com.fraudguard.security;
+
+import io.jsonwebtoken.*;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.stereotype.Service;
+
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.util.Date;
+
+@Service
+public class JwtService {
+    private static final String SECRET = "MySuperSecretKeyForJWTAuthentication12345";
+    private static final long EXPIRATION = 1000 * 60 * 60; // 1 hour
+    private final Key key = Keys.hmacShaKeyFor(SECRET.getBytes(StandardCharsets.UTF_8));
+
+    public String generateToken(String username) {
+        return Jwts.builder()
+                .setSubject(username)
+                .setIssuedAt(new Date(System.currentTimeMillis()))
+                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
+                .signWith(key, SignatureAlgorithm.HS256)
+                .compact();
+    }
+
+    public String extractUsername(String token) {
+        return Jwts.parserBuilder().setSigningKey(key).build()
+                .parseClaimsJws(token).getBody().getSubject();
+    }
+
+    public boolean isTokenValid(String token) {
+        try {
+            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
+            return true;
+        } catch (JwtException e) {
+            return false;
+        }
+    }
+}
diff --git a/backend/src/main/java/com/fraudguard/service/AlertService.java b/backend/src/main/java/com/fraudguard/service/AlertService.java
new file mode 100644
index 0000000..a6b9311
--- /dev/null
+++ b/backend/src/main/java/com/fraudguard/service/AlertService.java
@@ -0,0 +1,20 @@
+
+package com.fraudguard.service;
+
+import com.fraudguard.model.Alert;
+import com.fraudguard.repository.AlertRepository;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class AlertService {
+    private final AlertRepository repository;
+
+    public AlertService(AlertRepository repository) {
+        this.repository = repository;
+    }
+
+    public List<Alert> findAll() { return repository.findAll(); }
+    public Alert save(Alert a) { return repository.save(a); }
+}
diff --git a/backend/src/main/java/com/fraudguard/service/UserService.java b/backend/src/main/java/com/fraudguard/service/UserService.java
index 6cf05b7..d9e36a0 100644
--- a/backend/src/main/java/com/fraudguard/service/UserService.java
+++ b/backend/src/main/java/com/fraudguard/service/UserService.java
@@ -1,42 +1,40 @@
+
 package com.fraudguard.service;
 
-import com.fraudguard.dto.UserCreateRequest;
 import com.fraudguard.model.User;
 import com.fraudguard.repository.UserRepository;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
 
 @Service
-@Transactional
-@RequiredArgsConstructor
-@Slf4j
-public class UserService {
-    
+public class UserService implements UserDetailsService {
+
     private final UserRepository userRepository;
-    
-    public User createUser(UserCreateRequest request) {
-        log.info("Creating user with email: {}", request.getEmail());
-        
-        if (userRepository.existsByEmail(request.getEmail())) {
-            throw new RuntimeException("User already exists with email: " + request.getEmail());
-        }
-        
-        User user = new User(request.getEmail(), request.getFirstName(), request.getLastName());
-        user.setPhoneNumber(request.getPhoneNumber());
-        user.setCity(request.getCity());
-        user.setCountry(request.getCountry());
-        
-        User savedUser = userRepository.save(user);
-        log.info("User created successfully with ID: {}", savedUser.getId());
-        
-        return savedUser;
+    private final PasswordEncoder passwordEncoder;
+
+    public UserService(UserRepository userRepository, PasswordEncoder passwordEncoder) {
+        this.userRepository = userRepository;
+        this.passwordEncoder = passwordEncoder;
     }
-    
-    @Transactional(readOnly = true)
-    public User findByEmail(String email) {
-        return userRepository.findByEmail(email)
-            .orElseThrow(() -> new RuntimeException("User not found: " + email));
+
+    public User register(User user) {
+        user.setPassword(passwordEncoder.encode(user.getPassword()));
+        if (user.getRole() == null) user.setRole("ANALYST");
+        return userRepository.save(user);
+    }
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        User user = userRepository.findByUsername(username)
+                .orElseThrow(() -> new UsernameNotFoundException("User not found: " + username));
+        List<GrantedAuthority> auth = List.of(new SimpleGrantedAuthority("ROLE_" + (user.getRole()==null?"ANALYST":user.getRole())));
+        return new org.springframework.security.core.userdetails.User(user.getUsername(), (String) user.getPassword(), auth);
     }
 }
diff --git a/backend/src/main/resources/application-dev.yml b/backend/src/main/resources/application-dev.yml
deleted file mode 100644
index 31cf4e9..0000000
--- a/backend/src/main/resources/application-dev.yml
+++ /dev/null
@@ -1,43 +0,0 @@
-# Development Environment Configuration
-server:
-  port: 8081
-
-spring:
-  datasource:
-    url: jdbc:h2:mem:fraudguard_dev
-    username: sa
-    password: password
-    driver-class-name: org.h2.Driver
-    
-  jpa:
-    hibernate:
-      ddl-auto: create-drop
-    show-sql: true
-    properties:
-      hibernate:
-        format_sql: true
-        dialect: org.hibernate.dialect.H2Dialect
-  
-  h2:
-    console:
-      enabled: true
-      path: /h2-console
-
-# Disable Redis temporarily
-# redis:
-#   host: localhost
-#   port: 6379
-
-logging:
-  level:
-    root: INFO
-    com.fraudguard: DEBUG
-    org.springframework.web: DEBUG
-    org.hibernate: DEBUG
-
-fraudguard:
-  ml-service:
-    base-url: http://localhost:5000
-  fraud-detection:
-    score-threshold: 0.5
-    auto-block-threshold: 0.8
diff --git a/backend/src/main/resources/application-docker.yml b/backend/src/main/resources/application-docker.yml
deleted file mode 100644
index e69de29..0000000
diff --git a/backend/src/main/resources/application-h2.yml b/backend/src/main/resources/application-h2.yml
deleted file mode 100644
index 4b8c114..0000000
--- a/backend/src/main/resources/application-h2.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-server:
-  port: 8080
-
-spring:
-  datasource:
-    url: jdbc:h2:mem:fraudguard
-    username: sa
-    password: password
-    driver-class-name: org.h2.Driver
-    
-  jpa:
-    hibernate:
-      ddl-auto: create-drop
-    show-sql: true
-  
-  h2:
-    console:
-      enabled: true
-
-logging:
-  level:
-    com.fraudguard: DEBUG
diff --git a/backend/src/main/resources/application-minimal.yml b/backend/src/main/resources/application-minimal.yml
deleted file mode 100644
index 31c1281..0000000
--- a/backend/src/main/resources/application-minimal.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-server:
-  port: 8080
-
-spring:
-  datasource:
-    url: jdbc:h2:mem:fraudguard
-    username: sa
-    password: password
-    driver-class-name: org.h2.Driver
-    
-  jpa:
-    hibernate:
-      ddl-auto: create-drop
-    show-sql: true
-  
-  h2:
-    console:
-      enabled: true
-      path: /h2-console
-
-logging:
-  level:
-    com.fraudguard: DEBUG
diff --git a/backend/src/main/resources/application-prod.yml b/backend/src/main/resources/application-prod.yml
deleted file mode 100644
index 965e1ac..0000000
--- a/backend/src/main/resources/application-prod.yml
+++ /dev/null
@@ -1,42 +0,0 @@
-# Production Environment Configuration
-server:
-  port: 8080
-
-spring:
-  datasource:
-    url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/${DB_NAME:fraudguard_prod}
-    username: ${DB_USERNAME}
-    password: ${DB_PASSWORD}
-    hikari:
-      maximum-pool-size: 50
-      minimum-idle: 10
-      
-  jpa:
-    hibernate:
-      ddl-auto: validate
-    show-sql: false
-    
-  redis:
-    host: ${REDIS_HOST}
-    port: ${REDIS_PORT:6379}
-    password: ${REDIS_PASSWORD}
-
-logging:
-  level:
-    root: WARN
-    com.fraudguard: INFO
-  file:
-    name: /var/log/fraudguard/application.log
-
-management:
-  endpoints:
-    web:
-      exposure:
-        include: health,info,metrics,prometheus
-
-fraudguard:
-  ml-service:
-    base-url: ${ML_SERVICE_URL}
-  rate-limit:
-    requests-per-minute: 5000
-    burst-capacity: 10000
diff --git a/backend/src/main/resources/application-simple.yml b/backend/src/main/resources/application-simple.yml
deleted file mode 100644
index c7bedd3..0000000
--- a/backend/src/main/resources/application-simple.yml
+++ /dev/null
@@ -1,22 +0,0 @@
-server:
-  port: 8082
-
-spring:
-  datasource:
-    url: jdbc:h2:mem:fraudguard
-    username: sa
-    password: password
-    driver-class-name: org.h2.Driver
-    
-  jpa:
-    hibernate:
-      ddl-auto: create-drop
-    show-sql: true
-  
-  h2:
-    console:
-      enabled: true
-
-logging:
-  level:
-    com.fraudguard: DEBUG
diff --git a/backend/src/main/resources/application.properties b/backend/src/main/resources/application.properties
new file mode 100644
index 0000000..f4c9fa6
--- /dev/null
+++ b/backend/src/main/resources/application.properties
@@ -0,0 +1,24 @@
+# Server
+server.port=8080
+
+# Database (FIXED CONNECTION)
+spring.datasource.url=jdbc:mysql://localhost:3306/fraudguard?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
+spring.datasource.username=root
+spring.datasource.password=Harsh@123
+
+# JPA
+spring.jpa.hibernate.ddl-auto=update
+spring.jpa.show-sql=true
+spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
+spring.jpa.properties.hibernate.format_sql=true
+
+# Disable Hibernate dialect warnings
+spring.jpa.properties.hibernate.dialect.storage_engine=innodb
+
+# Optional: HikariCP connection pool settings
+spring.datasource.hikari.connection-timeout=20000
+spring.datasource.hikari.maximum-pool-size=5
+
+
+
+spring.main.allow-circular-references=true
\ No newline at end of file
diff --git a/backend/src/main/resources/application.yml b/backend/src/main/resources/application.yml
deleted file mode 100644
index 7c47086..0000000
--- a/backend/src/main/resources/application.yml
+++ /dev/null
@@ -1,214 +0,0 @@
-# Main Application Configuration
-server:
-  port: 8080
-  servlet:
-    context-path: /api/v1
-  error:
-    include-message: always
-    include-binding-errors: always
-
-spring:
-  application:
-    name: fraudguard-backend
-  
-  # Database Configuration
-  datasource:
-    url: jdbc:postgresql://localhost:5432/fraudguard_db
-    username: ${DB_USERNAME:fraudguard_user}
-    password: ${DB_PASSWORD:fraudguard_pass}
-    driver-class-name: org.postgresql.Driver
-    hikari:
-      maximum-pool-size: 20
-      minimum-idle: 5
-      idle-timeout: 300000
-      connection-timeout: 20000
-      leak-detection-threshold: 60000
-
-  # JPA Configuration
-  jpa:
-    hibernate:
-      ddl-auto: validate
-    show-sql: false
-    properties:
-      hibernate:
-        dialect: org.hibernate.dialect.PostgreSQLDialect
-        format_sql: true
-        use_sql_comments: true
-    open-in-view: false
-
-  # Redis Configuration
-  redis:
-    host: ${REDIS_HOST:localhost}
-    port: ${REDIS_PORT:6379}
-    password: ${REDIS_PASSWORD:}
-    timeout: 2000ms
-    jedis:
-      pool:
-        max-active: 20
-        max-idle: 10
-        min-idle: 5
-        max-wait: 1000ms
-
-  # Kafka Configuration
-  kafka:
-    bootstrap-servers: ${KAFKA_SERVERS:localhost:9092}
-    producer:
-      key-serializer: org.apache.kafka.common.serialization.StringSerializer
-      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
-      acks: all
-      retries: 3
-      batch-size: 16384
-      linger-ms: 5
-    consumer:
-      group-id: fraudguard-backend
-      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
-      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
-      auto-offset-reset: earliest
-      properties:
-        spring.json.trusted.packages: "com.fraudguard.model"
-
-  # Security Configuration
-  security:
-    oauth2:
-      resourceserver:
-        jwt:
-          issuer-uri: ${JWT_ISSUER_URI:http://localhost:8080/auth/realms/fraudguard}
-          jwk-set-uri: ${JWT_JWK_SET_URI:http://localhost:8080/auth/realms/fraudguard/protocol/openid-connect/certs}
-
-  # File Upload Configuration
-  servlet:
-    multipart:
-      max-file-size: 10MB
-      max-request-size: 15MB
-
-# Logging Configuration
-logging:
-  level:
-    com.fraudguard: DEBUG
-    org.springframework.security: DEBUG
-    org.springframework.web: INFO
-    org.hibernate.SQL: DEBUG
-  pattern:
-    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
-    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
-  file:
-    name: logs/fraudguard-backend.log
-    max-size: 10MB
-    max-history: 30
-
-# Management & Actuator Configuration
-management:
-  endpoints:
-    web:
-      exposure:
-        include: health,info,metrics,prometheus,loggers
-      base-path: /actuator
-  endpoint:
-    health:
-      show-details: always
-  metrics:
-    export:
-      prometheus:
-        enabled: true
-
-# FraudGuard Specific Configuration
-fraudguard:
-  ml-service:
-    base-url: ${ML_SERVICE_URL:http://localhost:5000}
-    timeout: 30000
-    retry-attempts: 3
-    
-  fraud-detection:
-    score-threshold: 0.7
-    high-risk-threshold: 0.9
-    auto-block-threshold: 0.95
-    batch-processing-size: 1000
-    
-  alerts:
-    email:
-      enabled: true
-      smtp-host: ${SMTP_HOST:localhost}
-      smtp-port: ${SMTP_PORT:587}
-      username: ${SMTP_USERNAME:}
-      password: ${SMTP_PASSWORD:}
-      from: ${ALERT_EMAIL_FROM:alerts@fraudguard.com}
-    webhook:
-      enabled: true
-      timeout: 5000
-      retry-attempts: 3
-      
-  rate-limit:
-    enabled: true
-    requests-per-minute: 1000
-    burst-capacity: 2000
-
-# Swagger Configuration
-springdoc:
-  api-docs:
-    path: /api-docs
-  swagger-ui:
-    path: /swagger-ui.html
-    operations-sorter: method
-    tags-sorter: alpha
-
----
-# Development Profile
-spring:
-  config:
-    activate:
-      on-profile: dev
-  datasource:
-    url: jdbc:postgresql://localhost:5432/fraudguard_dev
-  jpa:
-    hibernate:
-      ddl-auto: update
-    show-sql: true
-
-logging:
-  level:
-    root: INFO
-    com.fraudguard: DEBUG
-
----
-# Production Profile
-spring:
-  config:
-    activate:
-      on-profile: prod
-  datasource:
-    url: jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}
-    hikari:
-      maximum-pool-size: 50
-  jpa:
-    hibernate:
-      ddl-auto: validate
-    show-sql: false
-
-logging:
-  level:
-    root: WARN
-    com.fraudguard: INFO
-
----
-# Test Profile
-spring:
-  config:
-    activate:
-      on-profile: test
-  datasource:
-    url: jdbc:h2:mem:testdb
-    driver-class-name: org.h2.Driver
-    username: sa
-    password: password
-  jpa:
-    hibernate:
-      ddl-auto: create-drop
-    database-platform: org.hibernate.dialect.H2Dialect
-  h2:
-    console:
-      enabled: true
-
-logging:
-  level:
-    root: WARN
-    com.fraudguard: DEBUG
diff --git a/backend/src/main/resources/data.sql b/backend/src/main/resources/data.sql
index 9f02a03..cc77206 100644
--- a/backend/src/main/resources/data.sql
+++ b/backend/src/main/resources/data.sql
@@ -1,17 +1,9 @@
--- Sample Users
-INSERT INTO users (id, email, first_name, last_name, created_at, is_active) VALUES
-('550e8400-e29b-41d4-a716-446655440001', 'john.doe@example.com', 'John', 'Doe', NOW(), true),
-('550e8400-e29b-41d4-a716-446655440002', 'jane.smith@example.com', 'Jane', 'Smith', NOW(), true),
-('550e8400-e29b-41d4-a716-446655440003', 'suspicious@test.com', 'Test', 'User', NOW(), false);
 
--- Sample Merchants
-INSERT INTO merchants (id, name, category, country_code, risk_level) VALUES
-('merchant-001', 'Amazon', 'E-COMMERCE', 'US', 'LOW'),
-('merchant-002', 'Shell Gas Station', 'GAS_STATION', 'US', 'LOW'),
-('merchant-003', 'Suspicious Shop', 'OTHER', 'XX', 'HIGH');
+-- Sample seed data
+INSERT INTO users (username, email, password, role) VALUES
+ ('admin', 'admin@fraudguard.com', '$2a$10$6s3Zbq8r8i0D9gXw/9uQ3e4bC6S7v0JmJmB5n1D2p8cQFZ9s9d9y2', 'ADMIN'); -- password: admin123
 
--- Sample Fraud Rules
-INSERT INTO fraud_rules (id, name, description, rule_type, threshold_value, is_active) VALUES
-('rule-001', 'High Amount Transaction', 'Flag transactions over $10,000', 'AMOUNT', 10000.00, true),
-('rule-002', 'Velocity Check', 'More than 5 transactions in 1 hour', 'VELOCITY', 5.0, true),
-('rule-003', 'Geographic Anomaly', 'Transaction from unusual location', 'GEOGRAPHY', 1.0, true);
+INSERT INTO alert (title, description, severity, status) VALUES
+ ('Suspicious Transaction', 'Large wire transfer flagged', 'HIGH', 'NEW'),
+ ('Crypto Layering', 'Unusual crypto exchange activity', 'HIGH', 'IN_REVIEW'),
+ ('Structuring', 'Multiple deposits below threshold', 'MEDIUM', 'ESCALATED');
diff --git a/backend/src/main/resources/ehcache.xml b/backend/src/main/resources/ehcache.xml
deleted file mode 100644
index 6d9f967..0000000
--- a/backend/src/main/resources/ehcache.xml
+++ /dev/null
@@ -1,51 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
-         updateCheck="false">
-
-    <!-- Default cache configuration -->
-    <defaultCache
-        maxElementsInMemory="10000"
-        eternal="false"
-        timeToIdleSeconds="600"
-        timeToLiveSeconds="3600"
-        overflowToDisk="false"
-        diskPersistent="false"
-        memoryStoreEvictionPolicy="LRU"/>
-
-    <!-- User profiles cache -->
-    <cache name="userProfiles"
-           maxElementsInMemory="5000"
-           eternal="false"
-           timeToIdleSeconds="1800"
-           timeToLiveSeconds="3600"
-           overflowToDisk="false"
-           memoryStoreEvictionPolicy="LRU"/>
-
-    <!-- Fraud rules cache -->
-    <cache name="fraudRules"
-           maxElementsInMemory="1000"
-           eternal="false"
-           timeToIdleSeconds="3600"
-           timeToLiveSeconds="7200"
-           overflowToDisk="false"
-           memoryStoreEvictionPolicy="LRU"/>
-
-    <!-- Merchant data cache -->
-    <cache name="merchantData"
-           maxElementsInMemory="2000"
-           eternal="false"
-           timeToIdleSeconds="7200"
-           timeToLiveSeconds="14400"
-           overflowToDisk="false"
-           memoryStoreEvictionPolicy="LRU"/>
-
-    <!-- Transaction history cache -->
-    <cache name="transactionHistory"
-           maxElementsInMemory="10000"
-           eternal="false"
-           timeToIdleSeconds="300"
-           timeToLiveSeconds="900"
-           overflowToDisk="false"
-           memoryStoreEvictionPolicy="LRU"/>
-</ehcache>
diff --git a/backend/src/main/resources/schema.sql b/backend/src/main/resources/schema.sql
deleted file mode 100644
index f60d2b7..0000000
--- a/backend/src/main/resources/schema.sql
+++ /dev/null
@@ -1,93 +0,0 @@
--- Database Schema for FraudGuard
-CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-
--- Users Table
-CREATE TABLE IF NOT EXISTS users (
-    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-    email VARCHAR(255) UNIQUE NOT NULL,
-    password_hash VARCHAR(255),
-    first_name VARCHAR(100) NOT NULL,
-    last_name VARCHAR(100) NOT NULL,
-    phone VARCHAR(20),
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    last_login TIMESTAMP,
-    is_active BOOLEAN DEFAULT true,
-    risk_profile VARCHAR(50) DEFAULT 'LOW'
-);
-
--- Merchants Table
-CREATE TABLE IF NOT EXISTS merchants (
-    id VARCHAR(100) PRIMARY KEY,
-    name VARCHAR(255) NOT NULL,
-    category VARCHAR(100),
-    country_code VARCHAR(3),
-    risk_level VARCHAR(50) DEFAULT 'LOW',
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- Transactions Table
-CREATE TABLE IF NOT EXISTS transactions (
-    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-    user_id UUID REFERENCES users(id),
-    merchant_id VARCHAR(100) REFERENCES merchants(id),
-    amount DECIMAL(15,2) NOT NULL,
-    currency VARCHAR(3) NOT NULL DEFAULT 'USD',
-    transaction_type VARCHAR(50) NOT NULL,
-    status VARCHAR(50) DEFAULT 'PENDING',
-    fraud_score DECIMAL(5,4) DEFAULT 0.0,
-    risk_level VARCHAR(50) DEFAULT 'LOW',
-    location_country VARCHAR(3),
-    location_city VARCHAR(100),
-    device_fingerprint VARCHAR(255),
-    ip_address INET,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    processed_at TIMESTAMP
-);
-
--- Fraud Rules Table
-CREATE TABLE IF NOT EXISTS fraud_rules (
-    id VARCHAR(100) PRIMARY KEY,
-    name VARCHAR(255) NOT NULL,
-    description TEXT,
-    rule_type VARCHAR(50) NOT NULL,
-    threshold_value DECIMAL(15,4),
-    is_active BOOLEAN DEFAULT true,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
--- Fraud Alerts Table
-CREATE TABLE IF NOT EXISTS fraud_alerts (
-    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-    transaction_id UUID REFERENCES transactions(id),
-    user_id UUID REFERENCES users(id),
-    alert_type VARCHAR(50) NOT NULL,
-    severity VARCHAR(50) NOT NULL,
-    message TEXT,
-    status VARCHAR(50) DEFAULT 'OPEN',
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    resolved_at TIMESTAMP,
-    resolved_by UUID
-);
-
--- User Sessions Table
-CREATE TABLE IF NOT EXISTS user_sessions (
-    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-    user_id UUID REFERENCES users(id),
-    session_token VARCHAR(500) UNIQUE NOT NULL,
-    device_info TEXT,
-    ip_address INET,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    expires_at TIMESTAMP NOT NULL,
-    is_active BOOLEAN DEFAULT true
-);
-
--- Indexes for better performance
-CREATE INDEX IF NOT EXISTS idx_transactions_user_id ON transactions(user_id);
-CREATE INDEX IF NOT EXISTS idx_transactions_created_at ON transactions(created_at);
-CREATE INDEX IF NOT EXISTS idx_transactions_fraud_score ON transactions(fraud_score);
-CREATE INDEX IF NOT EXISTS idx_fraud_alerts_user_id ON fraud_alerts(user_id);
-CREATE INDEX IF NOT EXISTS idx_fraud_alerts_created_at ON fraud_alerts(created_at);
-CREATE INDEX IF NOT EXISTS idx_user_sessions_token ON user_sessions(session_token);
-CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
diff --git a/backend/src/main/resources/static/index.html b/backend/src/main/resources/static/index.html
new file mode 100644
index 0000000..483bdc4
--- /dev/null
+++ b/backend/src/main/resources/static/index.html
@@ -0,0 +1,214 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FraudGuard Enhanced: Advanced Money Laundering Detection</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <link rel="stylesheet" href="styles.css">
+</head>
+<body>
+   
+    <aside class="sidebar">
+        <div class="sidebar-header">
+            <i class="fas fa-shield-alt fa-2x"></i>
+            <h2>FraudGuard Enhanced</h2>
+        </div>
+        <nav class="sidebar-menu">
+            <ul>
+                <li><a href="#" class="active"><i class="fas fa-home"></i> <span>Dashboard</span></a></li>
+                <li><a href="#"><i class="fas fa-bell"></i> <span>Alerts</span></a></li>
+                <li><a href="#"><i class="fas fa-project-diagram"></i> <span>Network Analysis</span></a></li>
+                <li><a href="#"><i class="fas fa-user-circle"></i> <span>Customer Profiles</span></a></li>
+                <li><a href="#"><i class="fas fa-file-alt"></i> <span>SAR Manager</span></a></li>
+                <li><a href="#"><i class="fas fa-chart-line"></i> <span>Reports</span></a></li>
+                <li><a href="#"><i class="fas fa-cog"></i> <span>Settings</span></a></li>
+            </ul>
+        </nav>
+    </aside>
+
+   
+    <main class="main-content">
+        <div class="header">
+            <h1>Money Laundering Detection Dashboard</h1>
+            <div class="user-info">
+                <img src="https://ui-avatars.com/api/?name=Admin+User&background=0D8ABC&color=fff" alt="User">
+                <div>
+                    <div>Admin User</div>
+                    <div style="font-size: 0.8rem; color: var(--text-secondary);">Compliance Officer</div>
+                </div>
+            </div>
+        </div>
+
+       
+        <div class="dashboard-cards">
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">Total Alerts</div>
+                    <div class="card-icon" style="background: #e3f2fd; color: var(--primary);">
+                        <i class="fas fa-bell"></i>
+                    </div>
+                </div>
+                <div class="card-value">142</div>
+                <div class="card-trend">
+                    <i class="fas fa-arrow-up"></i> 12% from last week
+                </div>
+            </div>
+
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">High Priority Alerts</div>
+                    <div class="card-icon" style="background: #ffebee; color: var(--danger);">
+                        <i class="fas fa-exclamation-circle"></i>
+                    </div>
+                </div>
+                <div class="card-value">27</div>
+                <div class="card-trend down">
+                    <i class="fas fa-arrow-down"></i> 5% from last week
+                </div>
+            </div>
+
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">SARs Filed</div>
+                    <div class="card-icon" style="background: #e8f5e9; color: var(--success);">
+                        <i class="fas fa-file-contract"></i>
+                    </div>
+                </div>
+                <div class="card-value">18</div>
+                <div class="card-trend">
+                    <i class="fas fa-arrow-up"></i> 8% from last week
+                </div>
+            </div>
+
+            <div class="card">
+                <div class="card-header">
+                    <div class="card-title">Avg. Investigation Time</div>
+                    <div class="card-icon" style="background: #fff8e1; color: var(--warning);">
+                        <i class="fas fa-clock"></i>
+                    </div>
+                </div>
+                <div class="card-value">3.2h</div>
+                <div class="card-trend down">
+                    <i class="fas fa-arrow-down"></i> 15% from last week
+                </div>
+            </div>
+        </div>
+
+       
+        <div class="dashboard-cards">
+            <div class="chart-container">
+                <div class="chart-header">
+                    <div class="chart-title">Suspicious Activity by Type</div>
+                    <div class="chart-actions">
+                        <button>Last 7 Days</button>
+                        <button>Export</button>
+                    </div>
+                </div>
+                <div class="chart-canvas">
+                    <canvas id="activityChart"></canvas>
+                </div>
+            </div>
+
+            <div class="chart-container">
+                <div class="chart-header">
+                    <div class="chart-title">Detection Accuracy by Model</div>
+                    <div class="chart-actions">
+                        <button>Last 30 Days</button>
+                        <button>Export</button>
+                    </div>
+                </div>
+                <div class="chart-canvas">
+                    <canvas id="accuracyChart"></canvas>
+                </div>
+            </div>
+        </div>
+
+      
+        <div class="network-graph">
+            <div class="graph-placeholder">
+                <i class="fas fa-project-diagram"></i>
+                <h3>Transaction Network Analysis</h3>
+                <p>Visualization of complex money laundering networks</p>
+                <button style="margin-top: 20px; padding: 10px 20px; background: var(--primary); color: white; border: none; border-radius: 5px; cursor: pointer;">
+                    Launch Network Investigator
+                </button>
+            </div>
+        </div>
+
+       
+        <div class="alert-table">
+            <div class="chart-header">
+                <div class="chart-title">Recent High Priority Alerts</div>
+                <div class="chart-actions">
+                    <button>Filter</button>
+                    <button>Export</button>
+                </div>
+            </div>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Time</th>
+                        <th>Customer</th>
+                        <th>Amount</th>
+                        <th>Type</th>
+                        <th>Pattern</th>
+                        <th>Risk Score</th>
+                        <th>Status</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    <tr>
+                        <td>10:23 AM</td>
+                        <td>Global Imports Inc.</td>
+                        <td>$9,520.00</td>
+                        <td>Wire Transfer</td>
+                        <td>Structuring</td>
+                        <td><span class="badge badge-high">92%</span></td>
+                        <td>New</td>
+                    </tr>
+                    <tr>
+                        <td>09:45 AM</td>
+                        <td>John D. Smith</td>
+                        <td>$18,450.00</td>
+                        <td>Crypto Exchange</td>
+                        <td>Layering</td>
+                        <td><span class="badge badge-high">87%</span></td>
+                        <td>In Review</td>
+                    </tr>
+                    <tr>
+                        <td>09:12 AM</td>
+                        <td>EuroTrade LLC</td>
+                        <td>$47,800.00</td>
+                        <td>Business Payment</td>
+                        <td>Trade-Based</td>
+                        <td><span class="badge badge-high">95%</span></td>
+                        <td>New</td>
+                    </tr>
+                    <tr>
+                        <td>Yesterday</td>
+                        <td>Maria Rodriguez</td>
+                        <td>$12,300.00</td>
+                        <td>Multiple Deposits</td>
+                        <td>Structuring</td>
+                        <td><span class="badge badge-medium">76%</span></td>
+                        <td>Escalated</td>
+                    </tr>
+                    <tr>
+                        <td>Yesterday</td>
+                        <td>Digital Assets Co.</td>
+                        <td>$124,500.00</td>
+                        <td>Crypto Transfer</td>
+                        <td>Integration</td>
+                        <td><span class="badge badge-high">89%</span></td>
+                        <td>SAR Prepared</td>
+                    </tr>
+                </tbody>
+            </table>
+        </div>
+    </main>
+
+    <script src="script.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/backend/src/main/resources/static/script.js b/backend/src/main/resources/static/script.js
new file mode 100644
index 0000000..bf41e44
--- /dev/null
+++ b/backend/src/main/resources/static/script.js
@@ -0,0 +1,80 @@
+
+        document.addEventListener('DOMContentLoaded', function() {
+            
+            const activityCtx = document.getElementById('activityChart').getContext('2d');
+            const activityChart = new Chart(activityCtx, {
+                type: 'bar',
+                data: {
+                    labels: ['Structuring', 'Layering', 'Integration', 'Trade-Based', 'Crypto'],
+                    datasets: [{
+                        label: 'Number of Cases',
+                        data: [42, 28, 19, 31, 22],
+                        backgroundColor: [
+                            'rgba(255, 99, 132, 0.7)',
+                            'rgba(54, 162, 235, 0.7)',
+                            'rgba(255, 206, 86, 0.7)',
+                            'rgba(75, 192, 192, 0.7)',
+                            'rgba(153, 102, 255, 0.7)'
+                        ],
+                        borderColor: [
+                            'rgba(255, 99, 132, 1)',
+                            'rgba(54, 162, 235, 1)',
+                            'rgba(255, 206, 86, 1)',
+                            'rgba(75, 192, 192, 1)',
+                            'rgba(153, 102, 255, 1)'
+                        ],
+                        borderWidth: 1
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    scales: {
+                        y: {
+                            beginAtZero: true
+                        }
+                    }
+                }
+            });
+
+            const accuracyCtx = document.getElementById('accuracyChart').getContext('2d');
+            const accuracyChart = new Chart(accuracyCtx, {
+                type: 'radar',
+                data: {
+                    labels: ['SVM', 'Neural Network', 'Random Forest', 'LSTM', 'GRU'],
+                    datasets: [{
+                        label: 'Detection Accuracy (%)',
+                        data: [93.45, 92.14, 94.20, 91.80, 90.50],
+                        backgroundColor: 'rgba(26, 35, 126, 0.2)',
+                        borderColor: 'rgba(26, 35, 126, 1)',
+                        pointBackgroundColor: 'rgba(26, 35, 126, 1)',
+                        pointBorderColor: '#fff',
+                        pointHoverBackgroundColor: '#fff',
+                        pointHoverBorderColor: 'rgba(26, 35, 126, 1)'
+                    }]
+                },
+                options: {
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    scales: {
+                        r: {
+                            angleLines: {
+                                display: true
+                            },
+                            suggestedMin: 85,
+                            suggestedMax: 100
+                        }
+                    }
+                }
+            });
+
+            
+            setInterval(() => {
+              
+                document.querySelectorAll('.card-value')[0].textContent = 
+                    Math.floor(142 + Math.random() * 10);
+                
+                document.querySelectorAll('.card-value')[1].textContent = 
+                    Math.floor(27 + Math.random() * 5);
+            }, 10000);
+        });
\ No newline at end of file
diff --git a/backend/src/main/resources/static/styles.css b/backend/src/main/resources/static/styles.css
new file mode 100644
index 0000000..9697f15
--- /dev/null
+++ b/backend/src/main/resources/static/styles.css
@@ -0,0 +1,325 @@
+ :root {
+            --primary: #1a237e;
+            --primary-light: #534bae;
+            --primary-dark: #000051;
+            --secondary: #f5f5f5;
+            --accent: #00b0ff;
+            --danger: #f44336;
+            --warning: #ff9800;
+            --success: #4caf50;
+            --text-primary: #212121;
+            --text-secondary: #757575;
+            --card-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+            --sidebar-width: 260px;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+
+        body {
+            background-color: #f8f9fa;
+            color: var(--text-primary);
+            display: flex;
+            min-height: 100vh;
+        }
+
+      
+        .sidebar {
+            width: var(--sidebar-width);
+            background: var(--primary);
+            color: white;
+            position: fixed;
+            height: 100vh;
+            overflow-y: auto;
+            transition: all 0.3s ease;
+            z-index: 1000;
+        }
+
+        .sidebar-header {
+            padding: 20px;
+            background: var(--primary-dark);
+            display: flex;
+            align-items: center;
+            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+        }
+
+        .sidebar-header img {
+            width: 40px;
+            height: 40px;
+            margin-right: 10px;
+        }
+
+        .sidebar-header h2 {
+            font-size: 1.2rem;
+            font-weight: 600;
+        }
+
+        .sidebar-menu {
+            padding: 15px 0;
+        }
+
+        .sidebar-menu ul {
+            list-style: none;
+        }
+
+        .sidebar-menu li {
+            margin-bottom: 5px;
+        }
+
+        .sidebar-menu a {
+            color: rgba(255, 255, 255, 0.8);
+            text-decoration: none;
+            display: flex;
+            align-items: center;
+            padding: 12px 20px;
+            transition: all 0.3s;
+        }
+
+        .sidebar-menu a:hover, .sidebar-menu a.active {
+            background: var(--primary-light);
+            color: white;
+            border-left: 4px solid var(--accent);
+        }
+
+        .sidebar-menu i {
+            margin-right: 10px;
+            font-size: 1.1rem;
+        }
+
+        /* Main Content */
+        .main-content {
+            flex: 1;
+            margin-left: var(--sidebar-width);
+            padding: 20px;
+            transition: all 0.3s;
+        }
+
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 25px;
+            padding-bottom: 15px;
+            border-bottom: 1px solid #e0e0e0;
+        }
+
+        .header h1 {
+            font-size: 1.8rem;
+            color: var(--primary);
+        }
+
+        .user-info {
+            display: flex;
+            align-items: center;
+        }
+
+        .user-info img {
+            width: 40px;
+            height: 40px;
+            border-radius: 50%;
+            margin-right: 10px;
+        }
+
+       
+        .dashboard-cards {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+            gap: 20px;
+            margin-bottom: 25px;
+        }
+
+        .card {
+            background: white;
+            border-radius: 10px;
+            box-shadow: var(--card-shadow);
+            padding: 20px;
+            transition: transform 0.3s;
+        }
+
+        .card:hover {
+            transform: translateY(-5px);
+        }
+
+        .card-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .card-title {
+            font-size: 1.1rem;
+            color: var(--text-secondary);
+        }
+
+        .card-icon {
+            width: 50px;
+            height: 50px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.5rem;
+        }
+
+        .card-value {
+            font-size: 2rem;
+            font-weight: 700;
+            margin: 10px 0;
+        }
+
+        .card-trend {
+            display: flex;
+            align-items: center;
+            color: var(--success);
+            font-weight: 600;
+        }
+
+        .card-trend.down {
+            color: var(--danger);
+        }
+
+        .card-trend i {
+            margin-right: 5px;
+        }
+        .chart-container {
+            background: white;
+            border-radius: 10px;
+            box-shadow: var(--card-shadow);
+            padding: 20px;
+            margin-bottom: 25px;
+        }
+
+        .chart-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+        }
+
+        .chart-title {
+            font-size: 1.2rem;
+            color: var(--primary);
+        }
+
+        .chart-actions button {
+            background: var(--secondary);
+            border: none;
+            padding: 8px 15px;
+            border-radius: 5px;
+            cursor: pointer;
+            margin-left: 10px;
+            font-weight: 500;
+        }
+
+        .chart-canvas {
+            width: 100%;
+            height: 300px;
+        }
+
+        /* Alert Table */
+        .alert-table {
+            background: white;
+            border-radius: 10px;
+            box-shadow: var(--card-shadow);
+            padding: 20px;
+            margin-bottom: 25px;
+            overflow-x: auto;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        th, td {
+            padding: 15px;
+            text-align: left;
+            border-bottom: 1px solid #e0e0e0;
+        }
+
+        th {
+            color: var(--text-secondary);
+            font-weight: 600;
+        }
+
+        tr:hover {
+            background: #f5f5f5;
+        }
+
+        .badge {
+            padding: 5px 10px;
+            border-radius: 20px;
+            font-size: 0.8rem;
+            font-weight: 600;
+        }
+
+        .badge-high {
+            background: #ffebee;
+            color: var(--danger);
+        }
+
+        .badge-medium {
+            background: #fff8e1;
+            color: var(--warning);
+        }
+
+        .badge-low {
+            background: #e8f5e9;
+            color: var(--success);
+        }
+
+        /* Network Graph Placeholder */
+        .network-graph {
+            background: white;
+            border-radius: 10px;
+            box-shadow: var(--card-shadow);
+            padding: 20px;
+            margin-bottom: 25px;
+            height: 400px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            background: linear-gradient(135deg, #f5f7ff 0%, #e3ebff 100%);
+        }
+
+        .graph-placeholder {
+            text-align: center;
+            color: var(--primary-light);
+        }
+
+        .graph-placeholder i {
+            font-size: 4rem;
+            margin-bottom: 20px;
+        }
+
+        .graph-placeholder h3 {
+            font-size: 1.5rem;
+            margin-bottom: 10px;
+        }
+
+        /* Responsive Design */
+        @media (max-width: 992px) {
+            .sidebar {
+                width: 70px;
+            }
+            .sidebar-header h2, .sidebar-menu span {
+                display: none;
+            }
+            .sidebar-menu i {
+                margin-right: 0;
+            }
+            .main-content {
+                margin-left: 70px;
+            }
+        }
+
+        @media (max-width: 768px) {
+            .dashboard-cards {
+                grid-template-columns: 1fr;
+            }
+        }
\ No newline at end of file
diff --git a/backend/src/main/resources/validationmessages.properties b/backend/src/main/resources/validationmessages.properties
deleted file mode 100644
index 918a948..0000000
--- a/backend/src/main/resources/validationmessages.properties
+++ /dev/null
@@ -1,15 +0,0 @@
-# Custom Validation Messages
-javax.validation.constraints.NotNull.message=Field cannot be null
-javax.validation.constraints.NotEmpty.message=Field cannot be empty
-javax.validation.constraints.NotBlank.message=Field cannot be blank
-javax.validation.constraints.Size.message=Field size must be between {min} and {max}
-javax.validation.constraints.Email.message=Invalid email format
-javax.validation.constraints.Pattern.message=Field format is invalid
-javax.validation.constraints.DecimalMin.message=Value must be at least {value}
-javax.validation.constraints.DecimalMax.message=Value must be at most {value}
-
-# Custom FraudGuard Validations
-fraudguard.validation.currency.invalid=Invalid currency code
-fraudguard.validation.amount.negative=Amount cannot be negative
-fraudguard.validation.phone.invalid=Invalid phone number format
-fraudguard.validation.password.weak=Password must contain at least one uppercase, lowercase, digit and special character
diff --git a/backend/src/test.backup/java/com/fraudguard/FraudGuardApplicationTests.java b/backend/src/test.backup/java/com/fraudguard/FraudGuardApplicationTests.java
deleted file mode 100644
index d234b81..0000000
--- a/backend/src/test.backup/java/com/fraudguard/FraudGuardApplicationTests.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package com.fraudguard;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.context.ActiveProfiles;
-
-@SpringBootTest
-@ActiveProfiles("test")
-class FraudGuardApplicationTests {
-
-    @Test
-    void contextLoads() {
-        // Application context should load successfully
-    }
-
-    @Test
-    void mainMethodTest() {
-        // Test main method runs without errors
-        String[] args = {};
-        FraudGuardApplication.main(args);
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/config/TestConfig.java b/backend/src/test.backup/java/com/fraudguard/config/TestConfig.java
deleted file mode 100644
index 46080dc..0000000
--- a/backend/src/test.backup/java/com/fraudguard/config/TestConfig.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package com.fraudguard.config;
-
-import com.fraudguard.external.MLServiceClient;
-import org.mockito.Mockito;
-import org.springframework.boot.test.context.TestConfiguration;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Primary;
-import org.springframework.context.annotation.Profile;
-
-@TestConfiguration
-@Profile("test")
-public class TestConfig {
-
-    @Bean
-    @Primary
-    public MLServiceClient mockMLServiceClient() {
-        return Mockito.mock(MLServiceClient.class);
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/controller/FraudDetectionControllerTest.java b/backend/src/test.backup/java/com/fraudguard/controller/FraudDetectionControllerTest.java
deleted file mode 100644
index 192e556..0000000
--- a/backend/src/test.backup/java/com/fraudguard/controller/FraudDetectionControllerTest.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package com.fraudguard.controller;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fraudguard.dto.FraudAnalysisRequest;
-import com.fraudguard.dto.FraudAnalysisResponse;
-import com.fraudguard.service.FraudDetectionService;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.http.MediaType;
-import org.springframework.security.test.context.support.WithMockUser;
-import org.springframework.test.web.servlet.MockMvc;
-
-import java.math.BigDecimal;
-import java.util.UUID;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.when;
-import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-
-@WebMvcTest(FraudDetectionController.class)
-class FraudDetectionControllerTest {
-
-    @Autowired
-    private MockMvc mockMvc;
-
-    @MockBean
-    private FraudDetectionService fraudDetectionService;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    @Test
-    @WithMockUser(roles = "ANALYST")
-    void analyzeFraud_ShouldReturn200_WhenValidRequest() throws Exception {
-        // Given
-        FraudAnalysisRequest request = FraudAnalysisRequest.builder()
-                .transactionId(UUID.randomUUID())
-                .amount(new BigDecimal("500.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .userId(UUID.randomUUID())
-                .build();
-
-        FraudAnalysisResponse response = FraudAnalysisResponse.builder()
-                .transactionId(request.getTransactionId())
-                .fraudScore(new BigDecimal("0.75"))
-                .riskLevel("MEDIUM")
-                .approved(false)
-                .explanation("Transaction amount exceeds user's typical spending pattern")
-                .build();
-
-        when(fraudDetectionService.analyzeFraud(any(FraudAnalysisRequest.class)))
-                .thenReturn(response);
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/fraud/analyze")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isOk())
-                .andExpected(jsonPath("$.fraudScore").value(0.75))
-                .andExpected(jsonPath("$.riskLevel").value("MEDIUM"))
-                .andExpected(jsonPath("$.approved").value(false))
-                .andExpected(jsonPath("$.explanation").exists());
-    }
-
-    @Test
-    void analyzeFraud_ShouldReturn401_WhenNotAuthenticated() throws Exception {
-        // Given
-        FraudAnalysisRequest request = FraudAnalysisRequest.builder()
-                .transactionId(UUID.randomUUID())
-                .amount(new BigDecimal("500.00"))
-                .build();
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/fraud/analyze")
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isUnauthorized());
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/controller/TransactionControllerTest.java b/backend/src/test.backup/java/com/fraudguard/controller/TransactionControllerTest.java
deleted file mode 100644
index a041945..0000000
--- a/backend/src/test.backup/java/com/fraudguard/controller/TransactionControllerTest.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package com.fraudguard.controller;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fraudguard.dto.TransactionCreateRequest;
-import com.fraudguard.dto.TransactionResponse;
-import com.fraudguard.service.TransactionService;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.http.MediaType;
-import org.springframework.security.test.context.support.WithMockUser;
-import org.springframework.test.web.servlet.MockMvc;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.when;
-import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-
-@WebMvcTest(TransactionController.class)
-class TransactionControllerTest {
-
-    @Autowired
-    private MockMvc mockMvc;
-
-    @MockBean
-    private TransactionService transactionService;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    @Test
-    @WithMockUser(roles = "USER")
-    void processTransaction_ShouldReturn201_WhenValidRequest() throws Exception {
-        // Given
-        UUID userId = UUID.randomUUID();
-        TransactionCreateRequest request = TransactionCreateRequest.builder()
-                .userId(userId)
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .build();
-
-        TransactionResponse response = TransactionResponse.builder()
-                .id(UUID.randomUUID())
-                .userId(userId)
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .status("APPROVED")
-                .fraudScore(new BigDecimal("0.15"))
-                .riskLevel("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        when(transactionService.processTransaction(any(TransactionCreateRequest.class)))
-                .thenReturn(response);
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/transactions")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isCreated())
-                .andExpected(jsonPath("$.amount").value(100.00))
-                .andExpected(jsonPath("$.currency").value("USD"))
-                .andExpected(jsonPath("$.status").value("APPROVED"))
-                .andExpected(jsonPath("$.fraudScore").value(0.15))
-                .andExpected(jsonPath("$.riskLevel").value("LOW"));
-    }
-
-    @Test
-    @WithMockUser(roles = "USER")
-    void processTransaction_ShouldReturn400_WhenNegativeAmount() throws Exception {
-        // Given
-        TransactionCreateRequest request = TransactionCreateRequest.builder()
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("-100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .build();
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/transactions")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isBadRequest());
-    }
-
-    @Test
-    @WithMockUser(roles = "USER")
-    void processTransaction_ShouldReturn400_WhenMissingRequiredFields() throws Exception {
-        // Given
-        TransactionCreateRequest request = TransactionCreateRequest.builder()
-                .amount(new BigDecimal("100.00"))
-                // Missing userId, currency, etc.
-                .build();
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/transactions")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isBadRequest());
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/controller/UserControllerTest.java b/backend/src/test.backup/java/com/fraudguard/controller/UserControllerTest.java
deleted file mode 100644
index a4b5c28..0000000
--- a/backend/src/test.backup/java/com/fraudguard/controller/UserControllerTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-package com.fraudguard.controller;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fraudguard.dto.UserCreateRequest;
-import com.fraudguard.dto.UserResponse;
-import com.fraudguard.service.UserService;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.http.MediaType;
-import org.springframework.security.test.context.support.WithMockUser;
-import org.springframework.test.web.servlet.MockMvc;
-
-import java.util.UUID;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-
-@WebMvcTest(UserController.class)
-class UserControllerTest {
-
-    @Autowired
-    private MockMvc mockMvc;
-
-    @MockBean
-    private UserService userService;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    @Test
-    @WithMockUser(roles = "ADMIN")
-    void createUser_ShouldReturn201_WhenValidRequest() throws Exception {
-        // Given
-        UserCreateRequest request = UserCreateRequest.builder()
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .password("password123")
-                .build();
-
-        UserResponse response = UserResponse.builder()
-                .id(UUID.randomUUID())
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .isActive(true)
-                .build();
-
-        when(userService.createUser(any(UserCreateRequest.class))).thenReturn(response);
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/users")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpect(status().isCreated())
-                .andExpect(jsonPath("$.email").value("test@example.com"))
-                .andExpect(jsonPath("$.firstName").value("Test"))
-                .andExpect(jsonPath("$.lastName").value("User"));
-    }
-
-    @Test
-    @WithMockUser(roles = "ADMIN")
-    void getUserById_ShouldReturn200_WhenUserExists() throws Exception {
-        // Given
-        UUID userId = UUID.randomUUID();
-        UserResponse response = UserResponse.builder()
-                .id(userId)
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .build();
-
-        when(userService.getUserById(eq(userId))).thenReturn(response);
-
-        // When & Then
-        mockMvc.perform(get("/api/v1/users/{id}", userId))
-                .andExpected(status().isOk())
-                .andExpected(jsonPath("$.id").value(userId.toString()))
-                .andExpected(jsonPath("$.email").value("test@example.com"));
-    }
-
-    @Test
-    void createUser_ShouldReturn400_WhenInvalidEmail() throws Exception {
-        // Given
-        UserCreateRequest request = UserCreateRequest.builder()
-                .email("invalid-email")
-                .firstName("Test")
-                .lastName("User")
-                .password("password123")
-                .build();
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/users")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isBadRequest());
-    }
-
-    @Test
-    void createUser_ShouldReturn401_WhenNotAuthenticated() throws Exception {
-        // Given
-        UserCreateRequest request = UserCreateRequest.builder()
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .password("password123")
-                .build();
-
-        // When & Then
-        mockMvc.perform(post("/api/v1/users")
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-                .andExpected(status().isUnauthorized());
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/integration/BaseIntegrationTest.java b/backend/src/test.backup/java/com/fraudguard/integration/BaseIntegrationTest.java
deleted file mode 100644
index 0d7b916..0000000
--- a/backend/src/test.backup/java/com/fraudguard/integration/BaseIntegrationTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package com.fraudguard.integration;
-
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.test.context.ActiveProfiles;
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
-import org.testcontainers.containers.PostgreSQLContainer;
-import org.testcontainers.containers.GenericContainer;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-@ActiveProfiles("test")
-@Testcontainers
-public abstract class BaseIntegrationTest {
-
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13")
-            .withDatabaseName("fraudguard_test")
-            .withUsername("test")
-            .withPassword("test");
-
-    @Container
-    static GenericContainer<?> redis = new GenericContainer<>("redis:6-alpine")
-            .withExposedPorts(6379);
-
-    @DynamicPropertySource
-    static void configureProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-        registry.add("spring.datasource.username", postgres::getUsername);
-        registry.add("spring.datasource.password", postgres::getPassword);
-        
-        registry.add("spring.redis.host", redis::getHost);
-        registry.add("spring.redis.port", () -> redis.getMappedPort(6379).toString());
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/integration/KafkaIntegrationTest.java b/backend/src/test.backup/java/com/fraudguard/integration/KafkaIntegrationTest.java
deleted file mode 100644
index 5f83448..0000000
--- a/backend/src/test.backup/java/com/fraudguard/integration/KafkaIntegrationTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package com.fraudguard.integration;
-
-import com.fraudguard.dto.TransactionEvent;
-import com.fraudguard.service.messaging.TransactionEventProducer;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.kafka.annotation.KafkaListener;
-import org.springframework.kafka.test.context.EmbeddedKafka;
-import org.springframework.test.annotation.DirtiesContext;
-
-import java.math.BigDecimal;
-import java.util.UUID;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@EmbeddedKafka(partitions = 1, topics = {"transaction-events", "fraud-alerts"})
-@DirtiesContext
-class KafkaIntegrationTest extends BaseIntegrationTest {
-
-    @Autowired
-    private TransactionEventProducer transactionEventProducer;
-
-    private CountDownLatch latch = new CountDownLatch(1);
-    private TransactionEvent receivedEvent;
-
-    @Test
-    void shouldSendAndReceiveTransactionEvent() throws InterruptedException {
-        // Given
-        TransactionEvent event = TransactionEvent.builder()
-                .transactionId(UUID.randomUUID())
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("250.00"))
-                .currency("USD")
-                .merchantId("kafka-test-merchant")
-                .fraudScore(new BigDecimal("0.4"))
-                .riskLevel("MEDIUM")
-                .status("PENDING")
-                .build();
-
-        // When
-        transactionEventProducer.sendTransactionEvent(event);
-
-        // Then
-        boolean messageReceived = latch.await(10, TimeUnit.SECONDS);
-        assertThat(messageReceived).isTrue();
-        assertThat(receivedEvent).isNotNull();
-        assertThat(receivedEvent.getTransactionId()).isEqualTo(event.getTransactionId());
-        assertThat(receivedEvent.getAmount()).isEqualTo(new BigDecimal("250.00"));
-        assertThat(receivedEvent.getFraudScore()).isEqualTo(new BigDecimal("0.4"));
-    }
-
-    @KafkaListener(topics = "transaction-events", groupId = "test-group")
-    public void receiveTransactionEvent(ConsumerRecord<String, TransactionEvent> record) {
-        receivedEvent = record.value();
-        latch.countDown();
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/integration/TransactionIntegrationTest.java b/backend/src/test.backup/java/com/fraudguard/integration/TransactionIntegrationTest.java
deleted file mode 100644
index 1285a10..0000000
--- a/backend/src/test.backup/java/com/fraudguard/integration/TransactionIntegrationTest.java
+++ /dev/null
@@ -1,134 +0,0 @@
-
-package com.fraudguard.integration;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fraudguard.dto.TransactionCreateRequest;
-import com.fraudguard.dto.TransactionResponse;
-import com.fraudguard.entity.User;
-import com.fraudguard.repository.TransactionRepository;
-import com.fraudguard.repository.UserRepository;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.web.client.TestRestTemplate;
-import org.springframework.boot.test.web.server.LocalServerPort;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.math.BigDecimal;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@Transactional
-class TransactionIntegrationTest extends BaseIntegrationTest {
-
-    @LocalServerPort
-    private int port;
-
-    @Autowired
-    private TestRestTemplate restTemplate;
-
-    @Autowired
-    private TransactionRepository transactionRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    private String baseUrl;
-    private User testUser;
-
-    @BeforeEach
-    void setUp() {
-        baseUrl = "http://localhost:" + port + "/api/v1/transactions";
-        
-        testUser = userRepository.save(User.builder()
-                .id(UUID.randomUUID())
-                .email("transaction@test.com")
-                .firstName("Transaction")
-                .lastName("Test")
-                .isActive(true)
-                .riskProfile("LOW")
-                .build());
-    }
-
-    @Test
-    void processTransaction_ShouldPersistToDatabase_WhenValidRequest() {
-        // Given
-        TransactionCreateRequest request = TransactionCreateRequest.builder()
-                .userId(testUser.getId())
-                .amount(new BigDecimal("150.00"))
-                .currency("USD")
-                .merchantId("merchant-integration-001")
-                .transactionType("PURCHASE")
-                .ipAddress("192.168.1.100")
-                .deviceFingerprint("integration-device-123")
-                .build();
-
-        // When
-        ResponseEntity<TransactionResponse> response = restTemplate
-                .postForEntity(baseUrl, request, TransactionResponse.class);
-
-        // Then
-        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
-        assertThat(response.getBody()).isNotNull();
-        assertThat(response.getBody().getAmount()).isEqualTo(new BigDecimal("150.00"));
-        assertThat(response.getBody().getUserId()).isEqualTo(testUser.getId());
-        assertThat(response.getBody().getStatus()).isIn("APPROVED", "PENDING", "DECLINED");
-        assertThat(response.getBody().getFraudScore()).isBetween(BigDecimal.ZERO, BigDecimal.ONE);
-
-        // Verify database persistence
-        long transactionCount = transactionRepository.count();
-        assertThat(transactionCount).isGreaterThan(0);
-    }
-
-    @Test
-    void processTransaction_ShouldReturnBadRequest_WhenUserNotExists() {
-        // Given
-        TransactionCreateRequest request = TransactionCreateRequest.builder()
-                .userId(UUID.randomUUID()) // Non-existent user
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .build();
-
-        // When
-        ResponseEntity<String> response = restTemplate
-                .postForEntity(baseUrl, request, String.class);
-
-        // Then
-        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
-    }
-
-    @Test
-    void getTransactionById_ShouldReturnTransaction_WhenExists() {
-        // Given - Create transaction first
-        TransactionCreateRequest createRequest = TransactionCreateRequest.builder()
-                .userId(testUser.getId())
-                .amount(new BigDecimal("75.00"))
-                .currency("USD")
-                .merchantId("merchant-get-001")
-                .transactionType("PURCHASE")
-                .build();
-
-        ResponseEntity<TransactionResponse> createResponse = restTemplate
-                .postForEntity(baseUrl, createRequest, TransactionResponse.class);
-        
-        UUID transactionId = createResponse.getBody().getId();
-
-        // When
-        ResponseEntity<TransactionResponse> getResponse = restTemplate
-                .getForEntity(baseUrl + "/" + transactionId, TransactionResponse.class);
-
-        // Then
-        assertThat(getResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
-        assertThat(getResponse.getBody()).isNotNull();
-        assertThat(getResponse.getBody().getId()).isEqualTo(transactionId);
-        assertThat(getResponse.getBody().getAmount()).isEqualTo(new BigDecimal("75.00"));
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/integration/UserIntegration.java b/backend/src/test.backup/java/com/fraudguard/integration/UserIntegration.java
deleted file mode 100644
index 3642be0..0000000
--- a/backend/src/test.backup/java/com/fraudguard/integration/UserIntegration.java
+++ /dev/null
@@ -1,115 +0,0 @@
-package com.fraudguard.integration;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fraudguard.dto.UserCreateRequest;
-import com.fraudguard.dto.UserResponse;
-import com.fraudguard.entity.User;
-import com.fraudguard.repository.UserRepository;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.web.client.TestRestTemplate;
-import org.springframework.boot.test.web.server.LocalServerPort;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@Transactional
-class UserIntegrationTest extends BaseIntegrationTest {
-
-    @LocalServerPort
-    private int port;
-
-    @Autowired
-    private TestRestTemplate restTemplate;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    private String baseUrl;
-
-    @BeforeEach
-    void setUp() {
-        baseUrl = "http://localhost:" + port + "/api/v1/users";
-    }
-
-    @Test
-    void createUser_ShouldPersistToDatabase_WhenValidRequest() {
-        // Given
-        UserCreateRequest request = UserCreateRequest.builder()
-                .email("integration@test.com")
-                .firstName("Integration")
-                .lastName("Test")
-                .password("password123")
-                .build();
-
-        // When
-        ResponseEntity<UserResponse> response = restTemplate
-                .postForEntity(baseUrl, request, UserResponse.class);
-
-        // Then
-        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
-        assertThat(response.getBody()).isNotNull();
-        assertThat(response.getBody().getEmail()).isEqualTo("integration@test.com");
-
-        // Verify database persistence
-        boolean userExists = userRepository.existsByEmail("integration@test.com");
-        assertThat(userExists).isTrue();
-    }
-
-    @Test
-    void getUserById_ShouldReturnUser_WhenUserExistsInDatabase() {
-        // Given - Create user in database
-        User savedUser = userRepository.save(User.builder()
-                .id(UUID.randomUUID())
-                .email("existing@test.com")
-                .firstName("Existing")
-                .lastName("User")
-                .isActive(true)
-                .riskProfile("LOW")
-                .build());
-
-        // When
-        ResponseEntity<UserResponse> response = restTemplate
-                .getForEntity(baseUrl + "/" + savedUser.getId(), UserResponse.class);
-
-        // Then
-        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
-        assertThat(response.getBody()).isNotNull();
-        assertThat(response.getBody().getId()).isEqualTo(savedUser.getId());
-        assertThat(response.getBody().getEmail()).isEqualTo("existing@test.com");
-    }
-
-    @Test
-    void createUser_ShouldReturnConflict_WhenEmailAlreadyExists() {
-        // Given - Create user with existing email
-        userRepository.save(User.builder()
-                .id(UUID.randomUUID())
-                .email("duplicate@test.com")
-                .firstName("Existing")
-                .lastName("User")
-                .isActive(true)
-                .build());
-
-        UserCreateRequest request = UserCreateRequest.builder()
-                .email("duplicate@test.com")
-                .firstName("Duplicate")
-                .lastName("User")
-                .password("password123")
-                .build();
-
-        // When
-        ResponseEntity<String> response = restTemplate
-                .postForEntity(baseUrl, request, String.class);
-
-        // Then
-        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/repository/FraudRuleRepository.java b/backend/src/test.backup/java/com/fraudguard/repository/FraudRuleRepository.java
deleted file mode 100644
index 278f059..0000000
--- a/backend/src/test.backup/java/com/fraudguard/repository/FraudRuleRepository.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.entity.FraudRule;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.context.ActiveProfiles;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@DataJpaTest
-@ActiveProfiles("test")
-class FraudRuleRepositoryTest {
-
-    @Autowired
-    private TestEntityManager entityManager;
-
-    @Autowired
-    private FraudRuleRepository fraudRuleRepository;
-
-    private FraudRule activeRule;
-    private FraudRule inactiveRule;
-
-    @BeforeEach
-    void setUp() {
-        activeRule = FraudRule.builder()
-                .id("rule-001")
-                .name("High Amount Transaction")
-                .description("Flag transactions over $10,000")
-                .ruleType("AMOUNT")
-                .thresholdValue(new BigDecimal("10000.00"))
-                .isActive(true)
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        inactiveRule = FraudRule.builder()
-                .id("rule-002")
-                .name("Inactive Velocity Rule")
-                .description("Old velocity rule")
-                .ruleType("VELOCITY")
-                .thresholdValue(new BigDecimal("5.0"))
-                .isActive(false)
-                .createdAt(LocalDateTime.now())
-                .build();
-    }
-
-    @Test
-    void findByIsActiveTrue_ShouldReturnOnlyActiveRules() {
-        // Given
-        entityManager.persistAndFlush(activeRule);
-        entityManager.persistAndFlush(inactiveRule);
-
-        // When
-        List<FraudRule> activeRules = fraudRuleRepository.findByIsActiveTrue();
-
-        // Then
-        assertThat(activeRules).hasSize(1);
-        assertThat(activeRules.get(0).isActive()).isTrue();
-        assertThat(activeRules.get(0).getId()).isEqualTo("rule-001");
-    }
-
-    @Test
-    void findByRuleType_ShouldReturnRulesOfSpecificType() {
-        // Given
-        FraudRule anotherAmountRule = FraudRule.builder()
-                .id("rule-003")
-                .name("Medium Amount Rule")
-                .ruleType("AMOUNT")
-                .thresholdValue(new BigDecimal("5000.00"))
-                .isActive(true)
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        entityManager.persistAndFlush(activeRule); // AMOUNT type
-        entityManager.persistAndFlush(inactiveRule); // VELOCITY type
-        entityManager.persistAndFlush(anotherAmountRule); // AMOUNT type
-
-        // When
-        List<FraudRule> amountRules = fraudRuleRepository.findByRuleType("AMOUNT");
-
-        // Then
-        assertThat(amountRules).hasSize(2);
-        assertThat(amountRules).allMatch(rule -> rule.getRuleType().equals("AMOUNT"));
-    }
-
-    @Test
-    void findByRuleTypeAndIsActiveTrue_ShouldReturnActiveRulesOfType() {
-        // Given
-        entityManager.persistAndFlush(activeRule); // AMOUNT, active
-        entityManager.persistAndFlush(inactiveRule); // VELOCITY, inactive
-
-        // When
-        List<FraudRule> activeAmountRules = 
-                fraudRuleRepository.findByRuleTypeAndIsActiveTrue("AMOUNT");
-
-        // Then
-        assertThat(activeAmountRules).hasSize(1);
-        assertThat(activeAmountRules.get(0).getRuleType()).isEqualTo("AMOUNT");
-        assertThat(activeAmountRules.get(0).isActive()).isTrue();
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/repository/TransactionRepositoryTest.java b/backend/src/test.backup/java/com/fraudguard/repository/TransactionRepositoryTest.java
deleted file mode 100644
index 9906768..0000000
--- a/backend/src/test.backup/java/com/fraudguard/repository/TransactionRepositoryTest.java
+++ /dev/null
@@ -1,205 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.entity.Transaction;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.test.context.ActiveProfiles;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@DataJpaTest
-@ActiveProfiles("test")
-class TransactionRepositoryTest {
-
-    @Autowired
-    private TestEntityManager entityManager;
-
-    @Autowired
-    private TransactionRepository transactionRepository;
-
-    private UUID testUserId;
-    private Transaction testTransaction;
-
-    @BeforeEach
-    void setUp() {
-        testUserId = UUID.randomUUID();
-        testTransaction = Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(testUserId)
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .status("APPROVED")
-                .fraudScore(new BigDecimal("0.15"))
-                .riskLevel("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-    }
-
-    @Test
-    void findByUserId_ShouldReturnTransactions_ForSpecificUser() {
-        // Given
-        UUID otherUserId = UUID.randomUUID();
-        Transaction otherTransaction = createTransactionForUser(otherUserId);
-        
-        entityManager.persistAndFlush(testTransaction);
-        entityManager.persistAndFlush(otherTransaction);
-
-        // When
-        List<Transaction> userTransactions = transactionRepository.findByUserId(testUserId);
-
-        // Then
-        assertThat(userTransactions).hasSize(1);
-        assertThat(userTransactions.get(0).getUserId()).isEqualTo(testUserId);
-    }
-
-    @Test
-    void findByRiskLevel_ShouldReturnHighRiskTransactions() {
-        // Given
-        Transaction highRiskTxn = Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(testUserId)
-                .amount(new BigDecimal("5000.00"))
-                .fraudScore(new BigDecimal("0.95"))
-                .riskLevel("HIGH")
-                .status("DECLINED")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        entityManager.persistAndFlush(testTransaction); // LOW risk
-        entityManager.persistAndFlush(highRiskTxn); // HIGH risk
-
-        // When
-        List<Transaction> highRiskTransactions = transactionRepository.findByRiskLevel("HIGH");
-
-        // Then
-        assertThat(highRiskTransactions).hasSize(1);
-        assertThat(highRiskTransactions.get(0).getRiskLevel()).isEqualTo("HIGH");
-        assertThat(highRiskTransactions.get(0).getFraudScore()).isEqualTo(new BigDecimal("0.95"));
-    }
-
-    @Test
-    void findByUserIdAndCreatedAtBetween_ShouldReturnTransactionsInDateRange() {
-        // Given
-        LocalDateTime start = LocalDateTime.now().minusDays(1);
-        LocalDateTime end = LocalDateTime.now();
-        LocalDateTime oldDate = LocalDateTime.now().minusDays(2);
-
-        Transaction recentTxn = createTransactionWithDate(testUserId, start.plusHours(1));
-        Transaction oldTxn = createTransactionWithDate(testUserId, oldDate);
-
-        entityManager.persistAndFlush(recentTxn);
-        entityManager.persistAndFlush(oldTxn);
-
-        // When
-        List<Transaction> recentTransactions = transactionRepository
-                .findByUserIdAndCreatedAtBetween(testUserId, start, end);
-
-        // Then
-        assertThat(recentTransactions).hasSize(1);
-        assertThat(recentTransactions.get(0).getCreatedAt()).isAfter(start);
-        assertThat(recentTransactions.get(0).getCreatedAt()).isBefore(end);
-    }
-
-    @Test
-    void findByFraudScoreGreaterThan_ShouldReturnSuspiciousTransactions() {
-        // Given
-        Transaction suspiciousTxn = Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(testUserId)
-                .amount(new BigDecimal("1000.00"))
-                .fraudScore(new BigDecimal("0.85"))
-                .riskLevel("HIGH")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        entityManager.persistAndFlush(testTransaction); // Score 0.15
-        entityManager.persistAndFlush(suspiciousTxn); // Score 0.85
-
-        // When
-        List<Transaction> suspiciousTransactions = 
-                transactionRepository.findByFraudScoreGreaterThan(new BigDecimal("0.7"));
-
-        // Then
-        assertThat(suspiciousTransactions).hasSize(1);
-        assertThat(suspiciousTransactions.get(0).getFraudScore())
-                .isGreaterThan(new BigDecimal("0.7"));
-    }
-
-    @Test
-    void findByStatus_WithPagination_ShouldReturnPagedResults() {
-        // Given
-        for (int i = 0; i < 15; i++) {
-            Transaction txn = createTransactionWithStatus("APPROVED");
-            entityManager.persistAndFlush(txn);
-        }
-
-        PageRequest pageRequest = PageRequest.of(0, 10);
-
-        // When
-        Page<Transaction> approvedTransactions = 
-                transactionRepository.findByStatus("APPROVED", pageRequest);
-
-        // Then
-        assertThat(approvedTransactions.getContent()).hasSize(10);
-        assertThat(approvedTransactions.getTotalElements()).isEqualTo(15);
-        assertThat(approvedTransactions.getTotalPages()).isEqualTo(2);
-        assertThat(approvedTransactions.getNumber()).isEqualTo(0);
-    }
-
-    private Transaction createTransactionForUser(UUID userId) {
-        return Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(userId)
-                .amount(new BigDecimal("200.00"))
-                .currency("USD")
-                .merchantId("merchant-002")
-                .transactionType("PURCHASE")
-                .status("APPROVED")
-                .fraudScore(new BigDecimal("0.25"))
-                .riskLevel("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-    }
-
-    private Transaction createTransactionWithDate(UUID userId, LocalDateTime createdAt) {
-        return Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(userId)
-                .amount(new BigDecimal("150.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .status("APPROVED")
-                .fraudScore(new BigDecimal("0.20"))
-                .riskLevel("LOW")
-                .createdAt(createdAt)
-                .build();
-    }
-
-    private Transaction createTransactionWithStatus(String status) {
-        return Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .status(status)
-                .fraudScore(new BigDecimal("0.15"))
-                .riskLevel("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/repository/UserRepositoryTest.java b/backend/src/test.backup/java/com/fraudguard/repository/UserRepositoryTest.java
deleted file mode 100644
index ba6dd79..0000000
--- a/backend/src/test.backup/java/com/fraudguard/repository/UserRepositoryTest.java
+++ /dev/null
@@ -1,142 +0,0 @@
-package com.fraudguard.repository;
-
-import com.fraudguard.entity.User;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.springframework.test.context.ActiveProfiles;
-
-import java.time.LocalDateTime;
-import java.util.List;
-import java.util.Optional;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@DataJpaTest
-@ActiveProfiles("test")
-class UserRepositoryTest {
-
-    @Autowired
-    private TestEntityManager entityManager;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    private User testUser;
-
-    @BeforeEach
-    void setUp() {
-        testUser = User.builder()
-                .id(UUID.randomUUID())
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .passwordHash("hashed-password")
-                .isActive(true)
-                .riskProfile("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-    }
-
-    @Test
-    void findByEmail_ShouldReturnUser_WhenEmailExists() {
-        // Given
-        entityManager.persistAndFlush(testUser);
-
-        // When
-        Optional<User> result = userRepository.findByEmail("test@example.com");
-
-        // Then
-        assertThat(result).isPresent();
-        assertThat(result.get().getEmail()).isEqualTo("test@example.com");
-        assertThat(result.get().getFirstName()).isEqualTo("Test");
-    }
-
-    @Test
-    void findByEmail_ShouldReturnEmpty_WhenEmailNotExists() {
-        // When
-        Optional<User> result = userRepository.findByEmail("nonexistent@example.com");
-
-        // Then
-        assertThat(result).isEmpty();
-    }
-
-    @Test
-    void existsByEmail_ShouldReturnTrue_WhenEmailExists() {
-        // Given
-        entityManager.persistAndFlush(testUser);
-
-        // When
-        boolean exists = userRepository.existsByEmail("test@example.com");
-
-        // Then
-        assertThat(exists).isTrue();
-    }
-
-    @Test
-    void existsByEmail_ShouldReturnFalse_WhenEmailNotExists() {
-        // When
-        boolean exists = userRepository.existsByEmail("nonexistent@example.com");
-
-        // Then
-        assertThat(exists).isFalse();
-    }
-
-    @Test
-    void findByRiskProfile_ShouldReturnUsers_WithSpecificRiskProfile() {
-        // Given
-        User lowRiskUser = createUserWithRiskProfile("LOW");
-        User highRiskUser = createUserWithRiskProfile("HIGH");
-        
-        entityManager.persistAndFlush(lowRiskUser);
-        entityManager.persistAndFlush(highRiskUser);
-        entityManager.persistAndFlush(testUser); // Also LOW risk
-
-        // When
-        List<User> lowRiskUsers = userRepository.findByRiskProfile("LOW");
-
-        // Then
-        assertThat(lowRiskUsers).hasSize(2);
-        assertThat(lowRiskUsers).allMatch(user -> user.getRiskProfile().equals("LOW"));
-    }
-
-    @Test
-    void findActiveUsers_ShouldReturnOnlyActiveUsers() {
-        // Given
-        User inactiveUser = User.builder()
-                .id(UUID.randomUUID())
-                .email("inactive@example.com")
-                .firstName("Inactive")
-                .lastName("User")
-                .isActive(false)
-                .riskProfile("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        entityManager.persistAndFlush(testUser); // Active
-        entityManager.persistAndFlush(inactiveUser); // Inactive
-
-        // When
-        List<User> activeUsers = userRepository.findByIsActiveTrue();
-
-        // Then
-        assertThat(activeUsers).hasSize(1);
-        assertThat(activeUsers.get(0).isActive()).isTrue();
-        assertThat(activeUsers.get(0).getEmail()).isEqualTo("test@example.com");
-    }
-
-    private User createUserWithRiskProfile(String riskProfile) {
-        return User.builder()
-                .id(UUID.randomUUID())
-                .email(riskProfile.toLowerCase() + "@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .isActive(true)
-                .riskProfile(riskProfile)
-                .createdAt(LocalDateTime.now())
-                .build();
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/repository/UserSession.java b/backend/src/test.backup/java/com/fraudguard/repository/UserSession.java
deleted file mode 100644
index f7a29d8..0000000
--- a/backend/src/test.backup/java/com/fraudguard/repository/UserSession.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package com.fraudguard.model;
-
-import jakarta.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "user_sessions")
-public class UserSession {
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
-    
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "user_id", nullable = false)
-    private User user;
-    
-    @Column(name = "session_token", unique = true, nullable = false)
-    private String sessionToken;
-    
-    @Column(name = "ip_address")
-    private String ipAddress;
-    
-    @Column(name = "user_agent")
-    private String userAgent;
-    
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-    
-    @Column(name = "expires_at", nullable = false)
-    private LocalDateTime expiresAt;
-    
-    @Column(name = "is_active")
-    private Boolean isActive = true;
-    
-    // Constructors, getters, setters
-    public UserSession() {
-        this.createdAt = LocalDateTime.now();
-    }
-    
-    // Add getters and setters as needed
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/service/AlertServiceTest.java b/backend/src/test.backup/java/com/fraudguard/service/AlertServiceTest.java
deleted file mode 100644
index cea3f5f..0000000
--- a/backend/src/test.backup/java/com/fraudguard/service/AlertServiceTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package com.fraudguard.service;
-
-import com.fraudguard.dto.AlertCreateRequest;
-import com.fraudguard.dto.AlertResponse;
-import com.fraudguard.entity.Alert;
-import com.fraudguard.entity.Transaction;
-import com.fraudguard.repository.AlertRepository;
-import com.fraudguard.service.email.EmailService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-class AlertServiceTest {
-
-    @Mock
-    private AlertRepository alertRepository;
-
-    @Mock
-    private EmailService emailService;
-
-    @InjectMocks
-    private AlertService alertService;
-
-    private Transaction testTransaction;
-    private Alert testAlert;
-    private AlertCreateRequest createRequest;
-
-    @BeforeEach
-    void setUp() {
-        testTransaction = Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("10000.00"))
-                .fraudScore(new BigDecimal("0.95"))
-                .riskLevel("HIGH")
-                .build();
-
-        testAlert = Alert.builder()
-                .id(UUID.randomUUID())
-                .transactionId(testTransaction.getId())
-                .userId(testTransaction.getUserId())
-                .alertType("FRAUD_DETECTION")
-                .severity("HIGH")
-                .message("High fraud risk detected")
-                .status("OPEN")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        createRequest = AlertCreateRequest.builder()
-                .transactionId(testTransaction.getId())
-                .userId(testTransaction.getUserId())
-                .alertType("FRAUD_DETECTION")
-                .severity("HIGH")
-                .message("High fraud risk detected")
-                .build();
-    }
-
-    @Test
-    void createAlert_ShouldReturnAlert_WhenValidRequest() {
-        // Given
-        when(alertRepository.save(any(Alert.class))).thenReturn(testAlert);
-
-        // When
-        AlertResponse result = alertService.createAlert(createRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getTransactionId()).isEqualTo(testTransaction.getId());
-        assertThat(result.getAlertType()).isEqualTo("FRAUD_DETECTION");
-        assertThat(result.getSeverity()).isEqualTo("HIGH");
-        assertThat(result.getStatus()).isEqualTo("OPEN");
-        
-        verify(alertRepository).save(any(Alert.class));
-        verify(emailService).sendFraudAlert(any(Alert.class));
-    }
-
-    @Test
-    void createFraudAlert_ShouldCreateAlert_ForHighRiskTransaction() {
-        // Given
-        when(alertRepository.save(any(Alert.class))).thenReturn(testAlert);
-
-        // When
-        AlertResponse result = alertService.createFraudAlert(testTransaction);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getTransactionId()).isEqualTo(testTransaction.getId());
-        assertThat(result.getAlertType()).isEqualTo("FRAUD_DETECTION");
-        assertThat(result.getSeverity()).isEqualTo("HIGH");
-        
-        verify(alertRepository).save(any(Alert.class));
-        verify(emailService).sendFraudAlert(any(Alert.class));
-    }
-
-    @Test
-    void resolveAlert_ShouldUpdateAlertStatus() {
-        // Given
-        UUID alertId = testAlert.getId();
-        UUID resolvedBy = UUID.randomUUID();
-        testAlert.setStatus("RESOLVED");
-        testAlert.setResolvedAt(LocalDateTime.now());
-        testAlert.setResolvedBy(resolvedBy);
-
-        when(alertRepository.findById(alertId)).thenReturn(java.util.Optional.of(testAlert));
-        when(alertRepository.save(any(Alert.class))).thenReturn(testAlert);
-
-        // When
-        AlertResponse result = alertService.resolveAlert(alertId, resolvedBy, "False positive");
-
-        // Then
-        assertThat(result.getStatus()).isEqualTo("RESOLVED");
-        assertThat(result.getResolvedBy()).isEqualTo(resolvedBy);
-        
-        verify(alertRepository).findById(alertId);
-        verify(alertRepository).save(any(Alert.class));
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/service/FraudDetectionServiceTest.java b/backend/src/test.backup/java/com/fraudguard/service/FraudDetectionServiceTest.java
deleted file mode 100644
index 31f9c02..0000000
--- a/backend/src/test.backup/java/com/fraudguard/service/FraudDetectionServiceTest.java
+++ /dev/null
@@ -1,142 +0,0 @@
-package com.fraudguard.service;
-
-import com.fraudguard.dto.FraudAnalysisRequest;
-import com.fraudguard.dto.FraudAnalysisResponse;
-import com.fraudguard.entity.Transaction;
-import com.fraudguard.external.MLServiceClient;
-import com.fraudguard.service.fraud.FraudDetectionService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.math.BigDecimal;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.when;
-
-@ExtendWith(MockitoExtension.class)
-class FraudDetectionServiceTest {
-
-    @Mock
-    private MLServiceClient mlServiceClient;
-
-    @InjectMocks
-    private FraudDetectionService fraudDetectionService;
-
-    private Transaction testTransaction;
-    private FraudAnalysisRequest analysisRequest;
-
-    @BeforeEach
-    void setUp() {
-        testTransaction = Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .ipAddress("192.168.1.1")
-                .deviceFingerprint("device123")
-                .build();
-
-        analysisRequest = FraudAnalysisRequest.builder()
-                .transactionId(testTransaction.getId())
-                .amount(testTransaction.getAmount())
-                .currency(testTransaction.getCurrency())
-                .merchantId(testTransaction.getMerchantId())
-                .userId(testTransaction.getUserId())
-                .build();
-    }
-
-    @Test
-    void calculateFraudScore_ShouldReturnLowScore_ForNormalTransaction() {
-        // Given
-        when(mlServiceClient.getFraudScore(any())).thenReturn(new BigDecimal("0.15"));
-
-        // When
-        BigDecimal fraudScore = fraudDetectionService.calculateFraudScore(testTransaction);
-
-        // Then
-        assertThat(fraudScore).isEqualTo(new BigDecimal("0.15"));
-    }
-
-    @Test
-    void calculateFraudScore_ShouldReturnHighScore_ForSuspiciousTransaction() {
-        // Given
-        testTransaction.setAmount(new BigDecimal("50000.00")); // High amount
-        when(mlServiceClient.getFraudScore(any())).thenReturn(new BigDecimal("0.85"));
-
-        // When
-        BigDecimal fraudScore = fraudDetectionService.calculateFraudScore(testTransaction);
-
-        // Then
-        assertThat(fraudScore).isEqualTo(new BigDecimal("0.85"));
-    }
-
-    @Test
-    void determineRiskLevel_ShouldReturnLow_ForLowScore() {
-        // When
-        String riskLevel = fraudDetectionService.determineRiskLevel(new BigDecimal("0.2"));
-
-        // Then
-        assertThat(riskLevel).isEqualTo("LOW");
-    }
-
-    @Test
-    void determineRiskLevel_ShouldReturnMedium_ForMediumScore() {
-        // When
-        String riskLevel = fraudDetectionService.determineRiskLevel(new BigDecimal("0.5"));
-
-        // Then
-        assertThat(riskLevel).isEqualTo("MEDIUM");
-    }
-
-    @Test
-    void determineRiskLevel_ShouldReturnHigh_ForHighScore() {
-        // When
-        String riskLevel = fraudDetectionService.determineRiskLevel(new BigDecimal("0.9"));
-
-        // Then
-        assertThat(riskLevel).isEqualTo("HIGH");
-    }
-
-    @Test
-    void analyzeFraud_ShouldReturnAnalysis_WhenValidRequest() {
-        // Given
-        when(mlServiceClient.getFraudScore(any())).thenReturn(new BigDecimal("0.75"));
-
-        // When
-        FraudAnalysisResponse result = fraudDetectionService.analyzeFraud(analysisRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getTransactionId()).isEqualTo(analysisRequest.getTransactionId());
-        assertThat(result.getFraudScore()).isEqualTo(new BigDecimal("0.75"));
-        assertThat(result.getRiskLevel()).isEqualTo("MEDIUM");
-        assertThat(result.isApproved()).isFalse(); // Medium/High risk should not be approved
-        assertThat(result.getExplanation()).isNotNull();
-    }
-
-    @Test
-    void shouldApproveTransaction_ShouldReturnTrue_ForLowRisk() {
-        // When
-        boolean shouldApprove = fraudDetectionService.shouldApproveTransaction(new BigDecimal("0.25"));
-
-        // Then
-        assertThat(shouldApprove).isTrue();
-    }
-
-    @Test
-    void shouldApproveTransaction_ShouldReturnFalse_ForHighRisk() {
-        // When
-        boolean shouldApprove = fraudDetectionService.shouldApproveTransaction(new BigDecimal("0.85"));
-
-        // Then
-        assertThat(shouldApprove).isFalse();
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/service/TransactionServiceTest.java b/backend/src/test.backup/java/com/fraudguard/service/TransactionServiceTest.java
deleted file mode 100644
index f44c97d..0000000
--- a/backend/src/test.backup/java/com/fraudguard/service/TransactionServiceTest.java
+++ /dev/null
@@ -1,173 +0,0 @@
-package com.fraudguard.service;
-
-import com.fraudguard.dto.TransactionCreateRequest;
-import com.fraudguard.dto.TransactionResponse;
-import com.fraudguard.entity.Transaction;
-import com.fraudguard.entity.User;
-import com.fraudguard.repository.TransactionRepository;
-import com.fraudguard.repository.UserRepository;
-import com.fraudguard.service.fraud.FraudDetectionService;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.Optional;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-class TransactionServiceTest {
-
-    @Mock
-    private TransactionRepository transactionRepository;
-
-    @Mock
-    private UserRepository userRepository;
-
-    @Mock
-    private FraudDetectionService fraudDetectionService;
-
-    @InjectMocks
-    private TransactionService transactionService;
-
-    private User testUser;
-    private Transaction testTransaction;
-    private TransactionCreateRequest createRequest;
-
-    @BeforeEach
-    void setUp() {
-        testUser = User.builder()
-                .id(UUID.randomUUID())
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .isActive(true)
-                .riskProfile("LOW")
-                .build();
-
-        testTransaction = Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(testUser.getId())
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .status("APPROVED")
-                .fraudScore(new BigDecimal("0.15"))
-                .riskLevel("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        createRequest = TransactionCreateRequest.builder()
-                .userId(testUser.getId())
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .ipAddress("192.168.1.1")
-                .deviceFingerprint("device123")
-                .build();
-    }
-
-    @Test
-    void processTransaction_ShouldReturnApprovedTransaction_WhenLowRisk() {
-        // Given
-        when(userRepository.findById(testUser.getId())).thenReturn(Optional.of(testUser));
-        when(fraudDetectionService.calculateFraudScore(any(Transaction.class)))
-                .thenReturn(new BigDecimal("0.15"));
-        when(fraudDetectionService.determineRiskLevel(any(BigDecimal.class)))
-                .thenReturn("LOW");
-        when(transactionRepository.save(any(Transaction.class))).thenReturn(testTransaction);
-
-        // When
-        TransactionResponse result = transactionService.processTransaction(createRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getStatus()).isEqualTo("APPROVED");
-        assertThat(result.getFraudScore()).isEqualTo(new BigDecimal("0.15"));
-        assertThat(result.getRiskLevel()).isEqualTo("LOW");
-        assertThat(result.getAmount()).isEqualTo(new BigDecimal("100.00"));
-        
-        verify(userRepository).findById(testUser.getId());
-        verify(fraudDetectionService).calculateFraudScore(any(Transaction.class));
-        verify(transactionRepository).save(any(Transaction.class));
-    }
-
-    @Test
-    void processTransaction_ShouldReturnDeclinedTransaction_WhenHighRisk() {
-        // Given
-        testTransaction.setStatus("DECLINED");
-        testTransaction.setFraudScore(new BigDecimal("0.95"));
-        testTransaction.setRiskLevel("HIGH");
-
-        when(userRepository.findById(testUser.getId())).thenReturn(Optional.of(testUser));
-        when(fraudDetectionService.calculateFraudScore(any(Transaction.class)))
-                .thenReturn(new BigDecimal("0.95"));
-        when(fraudDetectionService.determineRiskLevel(any(BigDecimal.class)))
-                .thenReturn("HIGH");
-        when(transactionRepository.save(any(Transaction.class))).thenReturn(testTransaction);
-
-        // When
-        TransactionResponse result = transactionService.processTransaction(createRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getStatus()).isEqualTo("DECLINED");
-        assertThat(result.getFraudScore()).isEqualTo(new BigDecimal("0.95"));
-        assertThat(result.getRiskLevel()).isEqualTo("HIGH");
-        
-        verify(fraudDetectionService).calculateFraudScore(any(Transaction.class));
-        verify(transactionRepository).save(any(Transaction.class));
-    }
-
-    @Test
-    void processTransaction_ShouldReturnPendingTransaction_WhenMediumRisk() {
-        // Given
-        testTransaction.setStatus("PENDING");
-        testTransaction.setFraudScore(new BigDecimal("0.65"));
-        testTransaction.setRiskLevel("MEDIUM");
-
-        when(userRepository.findById(testUser.getId())).thenReturn(Optional.of(testUser));
-        when(fraudDetectionService.calculateFraudScore(any(Transaction.class)))
-                .thenReturn(new BigDecimal("0.65"));
-        when(fraudDetectionService.determineRiskLevel(any(BigDecimal.class)))
-                .thenReturn("MEDIUM");
-        when(transactionRepository.save(any(Transaction.class))).thenReturn(testTransaction);
-
-        // When
-        TransactionResponse result = transactionService.processTransaction(createRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getStatus()).isEqualTo("PENDING");
-        assertThat(result.getFraudScore()).isEqualTo(new BigDecimal("0.65"));
-        assertThat(result.getRiskLevel()).isEqualTo("MEDIUM");
-    }
-
-    @Test
-    void getTransactionById_ShouldReturnTransaction_WhenExists() {
-        // Given
-        UUID transactionId = testTransaction.getId();
-        when(transactionRepository.findById(transactionId)).thenReturn(Optional.of(testTransaction));
-
-        // When
-        TransactionResponse result = transactionService.getTransactionById(transactionId);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getId()).isEqualTo(transactionId);
-        assertThat(result.getAmount()).isEqualTo(testTransaction.getAmount());
-        
-        verify(transactionRepository).findById(transactionId);
-    }
-}
-
diff --git a/backend/src/test.backup/java/com/fraudguard/service/UserServiceTest.java b/backend/src/test.backup/java/com/fraudguard/service/UserServiceTest.java
deleted file mode 100644
index d4a0d7c..0000000
--- a/backend/src/test.backup/java/com/fraudguard/service/UserServiceTest.java
+++ /dev/null
@@ -1,146 +0,0 @@
-package com.fraudguard.service;
-
-import com.fraudguard.dto.UserCreateRequest;
-import com.fraudguard.dto.UserResponse;
-import com.fraudguard.entity.User;
-import com.fraudguard.exception.UserAlreadyExistsException;
-import com.fraudguard.exception.UserNotFoundException;
-import com.fraudguard.repository.UserRepository;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-import org.springframework.security.crypto.password.PasswordEncoder;
-
-import java.time.LocalDateTime;
-import java.util.Optional;
-import java.util.UUID;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-class UserServiceTest {
-
-    @Mock
-    private UserRepository userRepository;
-
-    @Mock
-    private PasswordEncoder passwordEncoder;
-
-    @InjectMocks
-    private UserService userService;
-
-    private User testUser;
-    private UserCreateRequest createRequest;
-
-    @BeforeEach
-    void setUp() {
-        testUser = User.builder()
-                .id(UUID.randomUUID())
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .passwordHash("encoded-password")
-                .isActive(true)
-                .riskProfile("LOW")
-                .createdAt(LocalDateTime.now())
-                .build();
-
-        createRequest = UserCreateRequest.builder()
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .password("password123")
-                .build();
-    }
-
-    @Test
-    void createUser_ShouldReturnUserResponse_WhenValidRequest() {
-        // Given
-        when(userRepository.existsByEmail(anyString())).thenReturn(false);
-        when(passwordEncoder.encode(anyString())).thenReturn("encoded-password");
-        when(userRepository.save(any(User.class))).thenReturn(testUser);
-
-        // When
-        UserResponse result = userService.createUser(createRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getEmail()).isEqualTo("test@example.com");
-        assertThat(result.getFirstName()).isEqualTo("Test");
-        assertThat(result.getLastName()).isEqualTo("User");
-        assertThat(result.isActive()).isTrue();
-        
-        verify(userRepository).existsByEmail("test@example.com");
-        verify(passwordEncoder).encode("password123");
-        verify(userRepository).save(any(User.class));
-    }
-
-    @Test
-    void createUser_ShouldThrowException_WhenEmailExists() {
-        // Given
-        when(userRepository.existsByEmail(anyString())).thenReturn(true);
-
-        // When & Then
-        assertThatThrownBy(() -> userService.createUser(createRequest))
-                .isInstanceOf(UserAlreadyExistsException.class)
-                .hasMessage("User already exists with email: test@example.com");
-                
-        verify(userRepository).existsByEmail("test@example.com");
-        verify(userRepository, never()).save(any(User.class));
-    }
-
-    @Test
-    void getUserById_ShouldReturnUser_WhenUserExists() {
-        // Given
-        UUID userId = testUser.getId();
-        when(userRepository.findById(userId)).thenReturn(Optional.of(testUser));
-
-        // When
-        UserResponse result = userService.getUserById(userId);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.getId()).isEqualTo(userId);
-        assertThat(result.getEmail()).isEqualTo(testUser.getEmail());
-        
-        verify(userRepository).findById(userId);
-    }
-
-    @Test
-    void getUserById_ShouldThrowException_WhenUserNotFound() {
-        // Given
-        UUID userId = UUID.randomUUID();
-        when(userRepository.findById(userId)).thenReturn(Optional.empty());
-
-        // When & Then
-        assertThatThrownBy(() -> userService.getUserById(userId))
-                .isInstanceOf(UserNotFoundException.class)
-                .hasMessage("User not found with ID: " + userId);
-                
-        verify(userRepository).findById(userId);
-    }
-
-    @Test
-    void updateUserRiskProfile_ShouldUpdateSuccessfully() {
-        // Given
-        UUID userId = testUser.getId();
-        String newRiskProfile = "HIGH";
-        when(userRepository.findById(userId)).thenReturn(Optional.of(testUser));
-        when(userRepository.save(any(User.class))).thenReturn(testUser);
-
-        // When
-        userService.updateUserRiskProfile(userId, newRiskProfile);
-
-        // Then
-        verify(userRepository).findById(userId);
-        verify(userRepository).save(argThat(user -> 
-            user.getRiskProfile().equals(newRiskProfile)));
-    }
-}
diff --git a/backend/src/test.backup/java/com/fraudguard/utils/TestDataBuilder.java b/backend/src/test.backup/java/com/fraudguard/utils/TestDataBuilder.java
deleted file mode 100644
index 9bf50c0..0000000
--- a/backend/src/test.backup/java/com/fraudguard/utils/TestDataBuilder.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package com.fraudguard.utils;
-
-import com.fraudguard.dto.TransactionCreateRequest;
-import com.fraudguard.dto.UserCreateRequest;
-import com.fraudguard.entity.Transaction;
-import com.fraudguard.entity.User;
-
-import java.math.BigDecimal;
-import java.time.LocalDateTime;
-import java.util.UUID;
-
-public class TestDataBuilder {
-
-    public static UserCreateRequest.UserCreateRequestBuilder defaultUserCreateRequest() {
-        return UserCreateRequest.builder()
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .password("password123");
-    }
-
-    public static User.UserBuilder defaultUser() {
-        return User.builder()
-                .id(UUID.randomUUID())
-                .email("test@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .passwordHash("hashed-password")
-                .isActive(true)
-                .riskProfile("LOW")
-                .createdAt(LocalDateTime.now());
-    }
-
-    public static TransactionCreateRequest.TransactionCreateRequestBuilder defaultTransactionCreateRequest() {
-        return TransactionCreateRequest.builder()
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .ipAddress("192.168.1.1")
-                .deviceFingerprint("device123");
-    }
-
-    public static Transaction.TransactionBuilder defaultTransaction() {
-        return Transaction.builder()
-                .id(UUID.randomUUID())
-                .userId(UUID.randomUUID())
-                .amount(new BigDecimal("100.00"))
-                .currency("USD")
-                .merchantId("merchant-001")
-                .transactionType("PURCHASE")
-                .status("APPROVED")
-                .fraudScore(new BigDecimal("0.15"))
-                .riskLevel("LOW")
-                .ipAddress("192.168.1.1")
-                .deviceFingerprint("device123")
-                .createdAt(LocalDateTime.now());
-    }
-
-    public static Transaction highRiskTransaction() {
-        return defaultTransaction()
-                .amount(new BigDecimal("10000.00"))
-                .fraudScore(new BigDecimal("0.95"))
-                .riskLevel("HIGH")
-                .status("DECLINED")
-                .build();
-    }
-
-    public static User highRiskUser() {
-        return defaultUser()
-                .email("highrisk@example.com")
-                .riskProfile("HIGH")
-                .build();
-    }
-}
diff --git a/backend/src/test.backup/resources/application-test.yaml b/backend/src/test.backup/resources/application-test.yaml
deleted file mode 100644
index 5420e89..0000000
--- a/backend/src/test.backup/resources/application-test.yaml
+++ /dev/null
@@ -1,56 +0,0 @@
-# Test Configuration
-spring:
-  datasource:
-    url: jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE
-    driver-class-name: org.h2.Driver
-    username: sa
-    password: password
-    
-  jpa:
-    hibernate:
-      ddl-auto: create-drop
-    database-platform: org.hibernate.dialect.H2Dialect
-    show-sql: false
-    
-  h2:
-    console:
-      enabled: true
-      path: /h2-console
-      
-  kafka:
-    bootstrap-servers: ${spring.embedded.kafka.brokers}
-    consumer:
-      group-id: test-group
-      auto-offset-reset: earliest
-      
-  redis:
-    host: localhost
-    port: 6370
-    timeout: 1000ms
-    
-  security:
-    oauth2:
-      resourceserver:
-        jwt:
-          issuer-uri: http://localhost:8089/auth/realms/test
-
-logging:
-  level:
-    root: WARN
-    com.fraudguard: DEBUG
-    org.springframework.test: INFO
-    org.springframework.kafka: WARN
-    
-fraudguard:
-  ml-service:
-    base-url: http://localhost:8089
-    timeout: 5000
-  fraud-detection:
-    score-threshold: 0.3
-    high-risk-threshold: 0.7
-    auto-block-threshold: 0.9
-  alerts:
-    email:
-      enabled: false
-    webhook:
-      enabled: false
diff --git a/backend/src/test.backup/resources/logback-test.xml b/backend/src/test.backup/resources/logback-test.xml
deleted file mode 100644
index 7a577fc..0000000
--- a/backend/src/test.backup/resources/logback-test.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<configuration>
-    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
-    
-    <!-- Console appender for tests -->
-    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-        </encoder>
-    </appender>
-    
-    <!-- Memory appender for test assertions -->
-    <appender name="MEMORY" class="ch.qos.logback.core.read.ListAppender">
-        <encoder>
-            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-        </encoder>
-    </appender>
-    
-    <!-- Test-specific loggers -->
-    <logger name="com.fraudguard" level="DEBUG" additivity="false">
-        <appender-ref ref="CONSOLE"/>
-        <appender-ref ref="MEMORY"/>
-    </logger>
-    
-    <logger name="org.springframework.test" level="INFO" additivity="false">
-        <appender-ref ref="CONSOLE"/>
-    </logger>
-    
-    <logger name="org.testcontainers" level="INFO" additivity="false">
-        <appender-ref ref="CONSOLE"/>
-    </logger>
-    
-    <root level="WARN">
-        <appender-ref ref="CONSOLE"/>
-    </root>
-</configuration>
diff --git a/backend/src/test.backup/resources/test-data.sql b/backend/src/test.backup/resources/test-data.sql
deleted file mode 100644
index 187d9bb..0000000
--- a/backend/src/test.backup/resources/test-data.sql
+++ /dev/null
@@ -1,15 +0,0 @@
--- Test data for integration tests
-INSERT INTO users (id, email, first_name, last_name, password_hash, is_active, risk_profile, created_at) VALUES
-('550e8400-e29b-41d4-a716-446655440001', 'test1@example.com', 'Test', 'User1', '$2a$10$hash1', true, 'LOW', CURRENT_TIMESTAMP),
-('550e8400-e29b-41d4-a716-446655440002', 'test2@example.com', 'Test', 'User2', '$2a$10$hash2', true, 'MEDIUM', CURRENT_TIMESTAMP),
-('550e8400-e29b-41d4-a716-446655440003', 'test3@example.com', 'Test', 'User3', '$2a$10$hash3', false, 'HIGH', CURRENT_TIMESTAMP);
-
-INSERT INTO merchants (id, name, category, country_code, risk_level, created_at) VALUES
-('test-merchant-1', 'Test Merchant 1', 'E-COMMERCE', 'US', 'LOW', CURRENT_TIMESTAMP),
-('test-merchant-2', 'Test Merchant 2', 'GAS_STATION', 'US', 'LOW', CURRENT_TIMESTAMP),
-('test-merchant-3', 'Risky Test Merchant', 'OTHER', 'XX', 'HIGH', CURRENT_TIMESTAMP);
-
-INSERT INTO fraud_rules (id, name, description, rule_type, threshold_value, is_active, created_at) VALUES
-('test-rule-1', 'Test High Amount', 'Test rule for high amounts', 'AMOUNT', 5000.00, true, CURRENT_TIMESTAMP),
-('test-rule-2', 'Test Velocity', 'Test rule for transaction velocity', 'VELOCITY', 10.0, true, CURRENT_TIMESTAMP),
-('test-rule-3', 'Inactive Test Rule', 'Inactive test rule', 'GEOGRAPHY', 1.0, false, CURRENT_TIMESTAMP);