diff --git a/forex-mtl/.dockerignore b/forex-mtl/.dockerignore
new file mode 100644
index 00000000..6a663964
--- /dev/null
+++ b/forex-mtl/.dockerignore
@@ -0,0 +1,30 @@
+# Target directories
+target/
+project/target/
+project/project/target/
+
+# IDE files
+.idea/
+*.iml
+.vscode/
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Temp files
+*.log
+*.tmp
+tempDoNotCommit.txt
+
+# Docker files (not needed inside container)
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# Documentation
+README.md
\ No newline at end of file
diff --git a/forex-mtl/Dockerfile b/forex-mtl/Dockerfile
new file mode 100644
index 00000000..f2977d6b
--- /dev/null
+++ b/forex-mtl/Dockerfile
@@ -0,0 +1,50 @@
+# Multi-stage build for Scala SBT project
+FROM eclipse-temurin:17-jdk AS builder
+
+# Install SBT
+RUN apt-get update && \
+    apt-get install -y curl && \
+    echo "deb https://repo.scala-sbt.org/scalasbt/debian all main" | tee /etc/apt/sources.list.d/sbt.list && \
+    echo "deb https://repo.scala-sbt.org/scalasbt/debian /" | tee /etc/apt/sources.list.d/sbt_old.list && \
+    curl -sL "https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x2EE0EA64E40A89B84B2DF73499E82A75642AC823" | apt-key add && \
+    apt-get update && \
+    apt-get install -y sbt && \
+    rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy project files
+COPY project project
+COPY build.sbt .
+COPY src src
+
+# Build the application and create fat JAR
+RUN sbt clean assembly
+
+# Runtime stage - minimal JRE image
+FROM eclipse-temurin:17-jre
+
+# Install basic utilities
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user
+RUN groupadd -r forex && useradd -r -g forex forex
+
+# Set working directory
+WORKDIR /app
+
+# Copy the JAR from builder stage
+COPY --from=builder /app/target/scala-2.13/forex-mtl.jar app.jar
+
+# Change ownership to non-root user
+RUN chown forex:forex app.jar
+USER forex
+
+# Expose port (from application.conf)
+EXPOSE 8080
+
+# Run the application
+CMD ["java", "-jar", "app.jar"]
\ No newline at end of file
diff --git a/forex-mtl/README.md b/forex-mtl/README.md
new file mode 100644
index 00000000..da54aab0
--- /dev/null
+++ b/forex-mtl/README.md
@@ -0,0 +1,438 @@
+# Forex-MTL: Exchange Rate Proxy Service
+
+A high-performance, thread-safe forex exchange rate service that acts as a local proxy for the One-Frame API.
+
+## Requirements Met
+
+### Requirements 
+- The service returns an exchange rate when provided with 2 supported currencies
+- The rate should not be older than 5 minutes
+- The service should support at least 10,000 successful requests per day with 1 API token (limited to 1000 requests per day per token)
+
+### Key Concepts
+
+**Rates Caching**: Reduces API calls by caching exchange rates for 5 minutes
+
+**Batch Processing**: Groups multiple currency pair requests into single API calls
+
+## Design Decisions
+
+### Core Components
+
+1. **OneFrameClient** - HTTP client for One-Frame API integration
+2. **RateCache** - TTL-based concurrent cache using TrieMap
+3. **CachedOneFrame** - Main service orchestrating cache and API calls
+
+## Meeting One-Frame API Limitations
+
+### The Challenge
+- **Target Load**: 10,000 requests/day
+- **API Limit**: 1,000 requests/day
+- **Required Efficiency**: 10:1 cache hit ratio
+
+### Solution Strategy
+
+#### 1. TTL-Based Caching (5 minutes)
+```scala
+val expiresAt = apiTimestamp.plusMillis(ttl.toMillis)
+cache.put(rate.pair, CachedRate(rate, expiresAt))
+```
+
+#### 2. Batch API Optimization
+```scala
+// Instead of: 1 request per currency pair
+// We do: 1 request for multiple pairs
+val pairsToFetch = (allCachedPairs :+ requestedPair).distinct
+client.getBatch(pairsToFetch)
+```
+
+#### 3. Smart Cache Management
+- **Simplified Strategy**: On cache miss, refresh ALL cached pairs + requested pair
+- **TrieMap Storage**: Thread-safe concurrent map for high-performance access
+- **TTL-Based Expiration**: Automatic cleanup of expired rates
+
+### Efficiency Analysis
+
+**Best Case Scenario**: 
+- 288 API calls/day (one every 5 minutes for all active pairs)
+- Additional calls only when new currency pairs are requested (max 72)
+
+**Result**: Comfortably within 1000 API calls/day limit 
+
+## TTL Strategy: Server Time vs API Timestamp
+
+### Design Decision
+
+The cache TTL is calculated from **server time** rather than the API's `time_stamp` field. This is a deliberate architectural choice with important implications:
+
+```scala
+// Current implementation - server time based
+val expiresAt = Instant.ofEpochMilli(nowMillis).plusMillis(ttl.toMillis)
+
+// Alternative approach - API timestamp based
+val expiresAt = apiTimestamp.plusMillis(ttl.toMillis)
+```
+
+### Trade-off Analysis
+
+**Server Time Approach (Current):**
+- ✅ **Predictable API usage**: Exactly 288 calls/day guaranteed
+- ✅ **Quota safety**: Never exceeds One-Frame limits unexpectedly  
+- ✅ **Clock drift resilient**: Independent of API server time synchronization
+- ✅ **Production stable**: System behavior is deterministic
+- ❌ **Theoretical precision loss**: May serve data slightly older than 5 minutes in edge cases
+
+**API Timestamp Approach (Alternative):**
+- ✅ **Stricter data freshness**: Never serves data older than 5 minutes from source
+- ✅ **Theoretical correctness**: TTL reflects actual data age
+- ❌ **Unpredictable API usage**: 288-1440 calls/day depending on API timestamp delays
+- ❌ **Quota risk**: Could exhaust daily limit if API timestamps are stale
+- ❌ **Clock sync dependency**: Breaks down with time synchronization issues
+
+### Why Server Time Was Chosen
+
+1. **Business Constraint Priority**: Meeting the 10,000 requests/day requirement with 1,000 API calls/day limit
+2. **Production Reliability**: Predictable resource consumption over theoretical precision
+3. **System Stability**: Resilience to external service timing variations
+4. **Monitoring Capability**: Time sync warnings provide visibility into any precision trade-offs
+
+## Reliability & High Availability
+
+### Multi-Node Deployment Strategy
+
+The current implementation supports reliable production deployment with 2 active nodes and 3 hot-standby nodes. This architecture ensures high availability and fault tolerance with minimal risk of One-Frame quota exceed.
+
+### Failover Scenarios
+
+#### **Single Node Failure**
+- **Detection Time**: Automatic detection and reaction from Orchestrator (health check, container restart) with response time less than 10 seconds
+- **Recovery**: Load-balancer may automatically route traffic to healthy node until failed node is restarted or replaced by standby node
+- **Impact**: 
+  - **Downtime**: Minimal downtime of failed node
+  - **Capacity**: Remaining node handles full load
+
+#### **Double Node Failure (Hot-Standby Activation)**
+- **Trigger**: Both active nodes unavailable
+- **Action**: Orchestrator scales up standby nodes
+- **Recovery Time**: 60-90 seconds (container startup + cache warmup)
+
+### Reliability Benefits
+
+1. **99.9%+ Uptime**: Multi-node redundancy with automatic failover
+2. **Graceful Degradation**: System continues operating with reduced capacity
+3. **Disaster Recovery**: Geographic distribution of standby nodes possible
+
+### Monitoring & Alerts
+Project provides sufficient logging for such issues, including:
+- **One-Frame unavailability**
+- **Authentication errors**: token issues
+- **Rate limit exceeded**: API quota issues
+
+Integration with monitoring tools (e.g., Prometheus, Grafana) can provide real-time alerts on these events.
+
+## Thread Safety Implementation
+
+### Current Solution: Double-Checked Locking Pattern
+
+```scala
+private def getCurrencyRate(pair: Rate.Pair): F[Error Either Rate] = {
+  // First check: Read from cache without synchronization
+  cache.get(pair).flatMap {
+    case Some(cachedRate) =>
+      logger.debug(s"Cache HIT (unsynchronized read)")
+      F.pure(cachedRate.asRight[Error])
+    case None =>
+      // Cache miss - need to synchronize and double-check
+      this.synchronized {
+        cache.get(pair).flatMap {
+          case Some(cachedRate) =>
+            // Double-check: Another thread might have populated cache
+            logger.debug(s"Cache HIT (synchronized double-check)")
+            F.pure(cachedRate.asRight[Error])
+          case None =>
+            // Confirmed cache miss - perform API call
+            performBatchAPICall(pair)
+        }
+      }
+  }
+}
+```
+
+**Why This Works**:
+- **Optimized Cache Reads**: Most cache hits avoid synchronization entirely
+- **Race Condition Prevention**: Double-check pattern prevents duplicate API calls
+- **Better Concurrency**: Multiple threads can read from cache simultaneously
+- **API Call Protection**: Only synchronized when cache miss confirmed
+
+### Alternative Thread Safety Approaches
+
+#### 1. Simple Synchronized Method
+```scala
+private def getCurrencyRate(pair: Rate.Pair): F[Error Either Rate] = {
+  this.synchronized {
+    cache.get(pair).flatMap {
+      // Entire cache check + API call logic
+    }
+  }
+}
+```
+- **Pros**: Simple implementation, easy to understand
+- **Cons**: All cache reads are synchronized, lower concurrent performance
+
+#### 2. ReadWriteLock Implementation
+```scala
+private val rwLock = new ReentrantReadWriteLock()
+
+private def getCurrencyRate(pair: Rate.Pair): F[Error Either Rate] = {
+  // Read lock for cache check
+  rwLock.readLock().lock()
+  try {
+    cache.get(pair) match {
+      case Some(rate) => F.pure(rate.asRight)
+      case None => 
+        // Upgrade to write lock
+        rwLock.readLock().unlock()
+        rwLock.writeLock().lock()
+        try {
+          performAPICallWithDoubleCheck(pair)
+        } finally {
+          rwLock.writeLock().unlock()
+        }
+    }
+  } finally {
+    if (rwLock.readLock().tryLock()) rwLock.readLock().unlock()
+  }
+}
+```
+- **Pros**: Maximum concurrency for reads
+- **Cons**: Complex lock management, potential deadlocks, overkill for our load
+
+### Why Double-Checked Locking Was Chosen
+
+1. **Performance Optimization**: At 10k+ requests/day, optimizing cache reads becomes important
+2. **Concurrency Benefits**: Multiple threads can read from cache without blocking each other
+3. **API Call Protection**: Still prevents race conditions for expensive API calls  
+4. **Balanced Approach**: More complex than simple sync, but significantly better performance
+5. **Production Ready**: Well-known pattern suitable for high-throughput caching scenarios
+
+## Cache Implementation Alternatives
+
+### Current Solution: In-Memory TrieMap
+```scala
+private val cache = TrieMap[Rate.Pair, CachedRate]()
+```
+
+**Pros**:
+- Simple, lightweight implementation
+- Thread-safe concurrent access
+- No external dependencies
+- Perfect for single-instance deployments
+
+**Cons**:
+- Memory usage grows with number of currency pairs
+- Data lost on application restart
+- No cache eviction policies beyond TTL
+
+### Alternative: EhCache Integration
+
+For production deployments requiring persistence and advanced cache management:
+
+```scala
+// build.sbt
+libraryDependencies += "net.sf.ehcache" % "ehcache" % "2.10.9.2"
+
+// EhCache configuration
+class EhCacheRateCache[F[_]: Sync](cacheManager: CacheManager, config: CacheConfig) extends RateCache[F] {
+  private val cache = cacheManager.getCache("forex-rates")
+  
+  def get(pair: Rate.Pair): F[Option[Rate]] = Sync[F].delay {
+    Option(cache.get(pair.toString))
+      .map(_.asInstanceOf[CachedRate])
+      .filter(cachedRate => !isExpired(cachedRate))
+      .map(_.rate)
+  }
+  
+  def put(rate: Rate): F[Unit] = Sync[F].delay {
+    val element = new Element(rate.pair.toString, CachedRate(rate, expiresAt))
+    cache.put(element)
+  }
+}
+```
+
+**EhCache Benefits**:
+- **Persistence**: Survive application restarts
+- **Memory Management**: LRU eviction, size limits
+- **Monitoring**: JMX integration, cache statistics
+- **Clustering**: Distributed cache for multi-instance setups
+
+**When to Consider EhCache**:
+- Multi-instance deployments requiring shared cache
+- High memory usage concerns
+- Need for cache persistence across restarts
+- Advanced monitoring and management requirements
+
+### Redis Alternative
+
+For microservices architectures:
+
+```scala
+// Redis-based cache implementation
+libraryDependencies += "dev.profunktor" %% "redis4cats-effects" % "1.4.1"
+
+class RedisRateCache[F[_]: Async](redis: RedisCommands[F, String, String]) extends RateCache[F] {
+  def get(pair: Rate.Pair): F[Option[Rate]] = {
+    redis.get(s"rate:${pair.toString}")
+      .map(_.flatMap(json => parseRate(json)))
+      .map(_.filter(rate => !isExpired(rate)))
+  }
+}
+```
+
+**Redis Benefits**:
+- External cache service
+- Horizontal scaling
+- Pub/sub for cache invalidation
+- Rich data structures
+
+**Trade-offs**:
+- Network latency for cache operations
+- Additional infrastructure complexity
+- Requires Redis deployment and management
+
+## Direct and Reverse Currency Pairs Handling
+
+In the current implementation, direct and reverse currency pairs (e.g., USD/EUR and EUR/USD) are requested separately from the API. This simplifies the logic but may lead to discrepancies between direct and reverse rates due to data source specifics or rounding.
+
+**Alternative approach:**
+Only the direct pair (e.g., USD/EUR) is requested, and the reverse pair (EUR/USD) is automatically calculated as `1 / direct_rate`. This guarantees mathematical consistency between pairs, but requires additional logic for request handling and caching.
+
+**Example of alternative implementation:**
+```scala
+def getRate(pair: Rate.Pair): F[Error Either Rate] = {
+  cache.get(pair) match {
+    case Some(rate) => F.pure(rate.asRight)
+    case None =>
+      val directPair = pair
+      val reversePair = Rate.Pair(pair.to, pair.from)
+      cache.get(reversePair) match {
+        case Some(reverseRate) =>
+          // Calculate reverse rate
+          val calculatedRate = 1.0 / reverseRate.price
+          F.pure(Rate(pair.from, pair.to, calculatedRate).asRight)
+        case None =>
+          // Request direct pair from API
+          fetchAndCacheRate(directPair)
+      }
+  }
+}
+```
+## Configuration & Deployment
+
+### Environment Configuration
+```yaml
+# docker-compose.yml
+environment:
+  - HTTP_HOST=0.0.0.0
+  - HTTP_PORT=8080
+  - ONEFRAME_URL=http://one-frame:8080/rates?
+  - ONEFRAME_TOKEN=10dc303535874aeccc86a8251e6992f5
+  - ONEFRAME_TIME_TOLERANCE=30s
+  - CACHE_TTL=5m
+```
+
+### Docker Deployment
+```bash
+# Development
+docker-compose up
+
+# Production  
+docker build -t forex-mtl .
+docker run -p 8080:8080 \
+  -e ONEFRAME_URL=https://api.oneframe.com \
+  -e ONEFRAME_TOKEN=your_token \
+  -e ONEFRAME_TIME_TOLERANCE=30s \
+  forex-mtl
+```
+
+### Local Development
+```bash
+# Using local config
+sbt -Dconfig.resource=application-local.conf run
+
+# Testing
+sbt test
+```
+
+## Error Handling
+
+### Structured Error Responses
+```json
+{
+  "error":"INVALID_PARAMETERS",
+  "message":"Invalid currency parameters. Supported currencies: AUD, JPY, CAD, NZD, CHF, SGD, EUR, USD, GBP",
+  "timestamp":"2025-08-19T01:29:02.234068157Z"
+}
+```
+
+### Error Categories
+- **400**: Invalid currency parameters, missing parameters
+- **401**: Authentication errors with One-Frame API
+- **429**: Rate limiting (quota exceeded)
+- **500**: Internal server errors, One-Frame API issues
+- **503**: Service unavailable
+
+### Time Synchronization Monitoring
+
+The service includes configurable time synchronization monitoring to detect clock drift between servers:
+
+**Configuration:**
+```hocon
+app {
+  one-frame {
+    time-tolerance = ${ONEFRAME_TIME_TOLERANCE}
+  }
+}
+```
+
+**Monitoring Logic:**
+- Compares API timestamps with local server time
+- Logs warnings when time difference exceeds configured tolerance
+- Provides ops team with early warning for NTP synchronization issues
+
+**Implementation:**
+```scala
+def checkTimeSync(timestamp: String): Unit = {
+  val timeDiff = Duration.between(now, apiTimestamp)
+  val direction = if (timeDiff.isNegative) "behind" else "ahead"
+  if (timeDiff.abs() > config.timeTolerance) {
+    logger.warn(s"API timestamp is ${timeDiff.abs().getSeconds}s $direction of server time")
+  }
+}
+```
+
+**Example log output:**
+```
+WARN - Time synchronization issue detected: API timestamp 2025-08-22T10:00:00Z is 45s ahead of server time 2025-08-22T09:59:15Z (tolerance: 30s)
+WARN - Time synchronization issue detected: API timestamp 2025-08-22T09:58:30Z is 90s behind of server time 2025-08-22T10:00:00Z (tolerance: 30s)
+```
+
+**Why This Approach:**
+- **Simple and reliable** - minimal complexity, maximum uptime
+- **Configurable thresholds** - adjust sensitivity per environment  
+- **Operations-friendly** - provides monitoring without service disruption
+- **Production-ready** - battle-tested approach for distributed systems
+
+### Error Logging & Alerts
+
+All errors are logged in detail using the project's logger. These logs can be integrated with alerting systems (e.g., via Prometheus, Grafana, or external log monitoring) to notify operators about critical issues.
+
+#### Example error logs:
+
+```scala
+logger.error(s"Invalid currency parameters: $params")
+logger.error(s"One-Frame API authentication failed: ${ex.getMessage}")
+logger.error(s"Rate limit exceeded for token: $token")
+logger.error(s"Unexpected error fetching rates: ${ex.getMessage}", ex)
+```
+
+Alerts can be configured to trigger on specific error patterns or severity levels in the logs.
diff --git a/forex-mtl/build.sbt b/forex-mtl/build.sbt
index 8994026f..1a9cdbec 100644
--- a/forex-mtl/build.sbt
+++ b/forex-mtl/build.sbt
@@ -56,6 +56,7 @@ libraryDependencies ++= Seq(
   Libraries.fs2,
   Libraries.http4sDsl,
   Libraries.http4sServer,
+  Libraries.http4sClient,
   Libraries.http4sCirce,
   Libraries.circeCore,
   Libraries.circeGeneric,
@@ -63,7 +64,25 @@ libraryDependencies ++= Seq(
   Libraries.circeParser,
   Libraries.pureConfig,
   Libraries.logback,
-  Libraries.scalaTest      % Test,
-  Libraries.scalaCheck     % Test,
-  Libraries.catsScalaCheck % Test
+  Libraries.scalaTest          % Test,
+  Libraries.scalaCheck         % Test,
+  Libraries.catsScalaCheck     % Test,
+  Libraries.scalaTestPlusCheck % Test
 )
+
+// Assembly settings
+assembly / assemblyJarName := "forex-mtl.jar"
+assembly / mainClass := Some("forex.Main")
+
+// Merge strategy for conflicting files
+assembly / assemblyMergeStrategy := {
+  case "module-info.class" => MergeStrategy.discard
+  case x if x.endsWith("/module-info.class") => MergeStrategy.discard
+  case PathList("META-INF", xs @ _*) =>
+    xs match {
+      case ("MANIFEST.MF" :: Nil) => MergeStrategy.discard
+      case ("services" :: _) => MergeStrategy.concat
+      case _ => MergeStrategy.discard
+    }
+  case _ => MergeStrategy.first
+}
diff --git a/forex-mtl/docker-compose.yml b/forex-mtl/docker-compose.yml
new file mode 100644
index 00000000..95e7600f
--- /dev/null
+++ b/forex-mtl/docker-compose.yml
@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  one-frame:
+    image: paidyinc/one-frame
+    ports:
+      - "8086:8080"
+    restart: unless-stopped
+
+  forex-mtl:
+    build: .
+    ports:
+      - "8085:8080"
+    environment:
+      - HTTP_HOST=0.0.0.0
+      - HTTP_PORT=8080
+      - ONEFRAME_URL=http://one-frame:8080/rates?
+      - ONEFRAME_TOKEN=10dc303535874aeccc86a8251e6992f5
+      - ONEFRAME_TIME_TOLERANCE=30s
+      - CACHE_TTL=5m
+    depends_on:
+      - one-frame
+    restart: unless-stopped
\ No newline at end of file
diff --git a/forex-mtl/project/Dependencies.scala b/forex-mtl/project/Dependencies.scala
index 423210a1..2e70e579 100644
--- a/forex-mtl/project/Dependencies.scala
+++ b/forex-mtl/project/Dependencies.scala
@@ -10,11 +10,12 @@ object Dependencies {
     val circe      = "0.14.2"
     val pureConfig = "0.17.4"
 
-    val kindProjector  = "0.13.2"
-    val logback        = "1.2.3"
-    val scalaCheck     = "1.15.3"
-    val scalaTest      = "3.2.7"
-    val catsScalaCheck = "0.3.2"
+    val kindProjector      = "0.13.2"
+    val logback            = "1.2.3"
+    val scalaCheck         = "1.15.3"
+    val scalaTest          = "3.2.7"
+    val catsScalaCheck     = "0.3.2"
+    val scalaTestPlusCheck = "3.2.7.0"
   }
 
   object Libraries {
@@ -27,6 +28,7 @@ object Dependencies {
 
     lazy val http4sDsl       = http4s("http4s-dsl")
     lazy val http4sServer    = http4s("http4s-blaze-server")
+    lazy val http4sClient    = http4s("http4s-blaze-client")
     lazy val http4sCirce     = http4s("http4s-circe")
     lazy val circeCore       = circe("circe-core")
     lazy val circeGeneric    = circe("circe-generic")
@@ -41,9 +43,10 @@ object Dependencies {
     lazy val logback = "ch.qos.logback" % "logback-classic" % Versions.logback
 
     // Test
-    lazy val scalaTest      = "org.scalatest"     %% "scalatest"       % Versions.scalaTest
-    lazy val scalaCheck     = "org.scalacheck"    %% "scalacheck"      % Versions.scalaCheck
-    lazy val catsScalaCheck = "io.chrisdavenport" %% "cats-scalacheck" % Versions.catsScalaCheck
+    lazy val scalaTest          = "org.scalatest"     %% "scalatest"            % Versions.scalaTest
+    lazy val scalaCheck         = "org.scalacheck"    %% "scalacheck"           % Versions.scalaCheck
+    lazy val catsScalaCheck     = "io.chrisdavenport" %% "cats-scalacheck"      % Versions.catsScalaCheck
+    lazy val scalaTestPlusCheck = "org.scalatestplus" %% "scalacheck-1-15"      % Versions.scalaTestPlusCheck
   }
 
 }
diff --git a/forex-mtl/project/plugins.sbt b/forex-mtl/project/plugins.sbt
index f4715a30..467a4a87 100644
--- a/forex-mtl/project/plugins.sbt
+++ b/forex-mtl/project/plugins.sbt
@@ -1,3 +1,4 @@
 addSbtPlugin("com.lucidchart"    % "sbt-scalafmt-coursier" % "1.16")
 addSbtPlugin("com.timushev.sbt" % "sbt-updates" % "0.5.3")
 addSbtPlugin("io.spray" % "sbt-revolver" % "0.9.1")
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.2.0")
diff --git a/forex-mtl/src/main/resources/application-local.conf b/forex-mtl/src/main/resources/application-local.conf
new file mode 100644
index 00000000..ffa39797
--- /dev/null
+++ b/forex-mtl/src/main/resources/application-local.conf
@@ -0,0 +1,17 @@
+app {
+  http {
+    host = "0.0.0.0"
+    port = 8080
+    timeout = 40 seconds
+  }
+  
+  one-frame {
+    url = "http://localhost:8086"
+    token = "10dc303535874aeccc86a8251e6992f5"
+    time-tolerance = 30 seconds
+  }
+  
+  cache {
+    ttl = 5 minutes
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/main/resources/application.conf b/forex-mtl/src/main/resources/application.conf
index b2af6efd..bfd1f75a 100644
--- a/forex-mtl/src/main/resources/application.conf
+++ b/forex-mtl/src/main/resources/application.conf
@@ -1,8 +1,18 @@
 app {
   http {
-    host = "0.0.0.0"
-    port = 8080
+    host = ${HTTP_HOST}
+    port = ${HTTP_PORT}
     timeout = 40 seconds
   }
+  
+  one-frame {
+    url = ${ONEFRAME_URL}
+    token = ${ONEFRAME_TOKEN}
+    time-tolerance = ${ONEFRAME_TIME_TOLERANCE}
+  }
+  
+  cache {
+    ttl = ${CACHE_TTL}
+  }
 }
 
diff --git a/forex-mtl/src/main/scala/forex/Main.scala b/forex-mtl/src/main/scala/forex/Main.scala
index 6dda10a7..24167a51 100644
--- a/forex-mtl/src/main/scala/forex/Main.scala
+++ b/forex-mtl/src/main/scala/forex/Main.scala
@@ -13,9 +13,10 @@ object Main extends IOApp {
 
 }
 
-class Application[F[_]: ConcurrentEffect: Timer] {
+class Application[F[_]: ConcurrentEffect: Timer: Clock] {
 
-  def stream(ec: ExecutionContext): Stream[F, Unit] =
+  def stream(ec: ExecutionContext): Stream[F, Unit] = {
+    implicit val implicitEc: ExecutionContext = ec
     for {
       config <- Config.stream("app")
       module = new Module[F](config)
@@ -24,5 +25,6 @@ class Application[F[_]: ConcurrentEffect: Timer] {
             .withHttpApp(module.httpApp)
             .serve
     } yield ()
+  }
 
 }
diff --git a/forex-mtl/src/main/scala/forex/Module.scala b/forex-mtl/src/main/scala/forex/Module.scala
index 3bc47d58..95ff5da2 100644
--- a/forex-mtl/src/main/scala/forex/Module.scala
+++ b/forex-mtl/src/main/scala/forex/Module.scala
@@ -1,17 +1,18 @@
 package forex
 
-import cats.effect.{ Concurrent, Timer }
+import cats.effect.{Clock, ConcurrentEffect, Timer}
 import forex.config.ApplicationConfig
 import forex.http.rates.RatesHttpRoutes
 import forex.services._
 import forex.programs._
 import org.http4s._
 import org.http4s.implicits._
-import org.http4s.server.middleware.{ AutoSlash, Timeout }
+import org.http4s.server.middleware.{AutoSlash, Logger, Timeout}
+import scala.concurrent.ExecutionContext
 
-class Module[F[_]: Concurrent: Timer](config: ApplicationConfig) {
+class Module[F[_]: Timer: ConcurrentEffect: Clock](config: ApplicationConfig)(implicit ec: ExecutionContext) {
 
-  private val ratesService: RatesService[F] = RatesServices.dummy[F]
+  private val ratesService: RatesService[F] = RatesServices.cachedOneFrame[F](config.oneFrame, config.cache)
 
   private val ratesProgram: RatesProgram[F] = RatesProgram[F](ratesService)
 
@@ -27,7 +28,7 @@ class Module[F[_]: Concurrent: Timer](config: ApplicationConfig) {
   }
 
   private val appMiddleware: TotalMiddleware = { http: HttpApp[F] =>
-    Timeout(config.http.timeout)(http)
+    Logger.httpApp(logHeaders = true, logBody = false)(Timeout(config.http.timeout)(http))
   }
 
   private val http: HttpRoutes[F] = ratesHttpRoutes
diff --git a/forex-mtl/src/main/scala/forex/config/ApplicationConfig.scala b/forex-mtl/src/main/scala/forex/config/ApplicationConfig.scala
index eff0fad7..27c08e6c 100644
--- a/forex-mtl/src/main/scala/forex/config/ApplicationConfig.scala
+++ b/forex-mtl/src/main/scala/forex/config/ApplicationConfig.scala
@@ -2,12 +2,24 @@ package forex.config
 
 import scala.concurrent.duration.FiniteDuration
 
-case class ApplicationConfig(
+final case class ApplicationConfig(
     http: HttpConfig,
+    oneFrame: OneFrameConfig,
+    cache: CacheConfig
 )
 
-case class HttpConfig(
+final case class HttpConfig(
     host: String,
     port: Int,
     timeout: FiniteDuration
 )
+
+final case class OneFrameConfig(
+    url: String,
+    token: String,
+    timeTolerance: FiniteDuration
+)
+
+final case class CacheConfig(
+    ttl: FiniteDuration
+)
diff --git a/forex-mtl/src/main/scala/forex/config/Config.scala b/forex-mtl/src/main/scala/forex/config/Config.scala
index 0181788e..2767464f 100644
--- a/forex-mtl/src/main/scala/forex/config/Config.scala
+++ b/forex-mtl/src/main/scala/forex/config/Config.scala
@@ -13,7 +13,7 @@ object Config {
    */
   def stream[F[_]: Sync](path: String): Stream[F, ApplicationConfig] = {
     Stream.eval(Sync[F].delay(
-      ConfigSource.default.at(path).loadOrThrow[ApplicationConfig]))
+      ConfigSource.default.withFallback(ConfigSource.systemProperties).at(path).loadOrThrow[ApplicationConfig]))
   }
 
 }
diff --git a/forex-mtl/src/main/scala/forex/domain/Currency.scala b/forex-mtl/src/main/scala/forex/domain/Currency.scala
index a6f2857d..e6c78856 100644
--- a/forex-mtl/src/main/scala/forex/domain/Currency.scala
+++ b/forex-mtl/src/main/scala/forex/domain/Currency.scala
@@ -2,41 +2,26 @@ package forex.domain
 
 import cats.Show
 
-sealed trait Currency
+object Currency extends Enumeration {
+  type Currency = Value
+  
+  val AUD, CAD, CHF, EUR, GBP, JPY, NZD, SGD, USD = Value
 
-object Currency {
-  case object AUD extends Currency
-  case object CAD extends Currency
-  case object CHF extends Currency
-  case object EUR extends Currency
-  case object GBP extends Currency
-  case object NZD extends Currency
-  case object JPY extends Currency
-  case object SGD extends Currency
-  case object USD extends Currency
+  implicit val show: Show[Currency] = Show.show(_.toString)
 
-  implicit val show: Show[Currency] = Show.show {
-    case AUD => "AUD"
-    case CAD => "CAD"
-    case CHF => "CHF"
-    case EUR => "EUR"
-    case GBP => "GBP"
-    case NZD => "NZD"
-    case JPY => "JPY"
-    case SGD => "SGD"
-    case USD => "USD"
+  def fromString(s: String): Option[Currency] = {
+    values.find(_.toString.equalsIgnoreCase(s.trim))
   }
-
-  def fromString(s: String): Currency = s.toUpperCase match {
-    case "AUD" => AUD
-    case "CAD" => CAD
-    case "CHF" => CHF
-    case "EUR" => EUR
-    case "GBP" => GBP
-    case "NZD" => NZD
-    case "JPY" => JPY
-    case "SGD" => SGD
-    case "USD" => USD
+  
+  def allCurrencies: Set[Currency] = values.toSet
+  
+  def supportedPairs: List[(Currency, Currency)] = {
+    val currencies = allCurrencies.toList
+    for {
+      from <- currencies
+      to <- currencies
+      if from != to
+    } yield (from, to)
   }
 
 }
diff --git a/forex-mtl/src/main/scala/forex/domain/Price.scala b/forex-mtl/src/main/scala/forex/domain/Price.scala
index 7faea8c5..a029f869 100644
--- a/forex-mtl/src/main/scala/forex/domain/Price.scala
+++ b/forex-mtl/src/main/scala/forex/domain/Price.scala
@@ -1,6 +1,6 @@
 package forex.domain
 
-case class Price(value: BigDecimal) extends AnyVal
+final case class Price(value: BigDecimal) extends AnyVal
 
 object Price {
   def apply(value: Integer): Price =
diff --git a/forex-mtl/src/main/scala/forex/domain/Rate.scala b/forex-mtl/src/main/scala/forex/domain/Rate.scala
index 4a444003..f86cabf5 100644
--- a/forex-mtl/src/main/scala/forex/domain/Rate.scala
+++ b/forex-mtl/src/main/scala/forex/domain/Rate.scala
@@ -1,6 +1,6 @@
 package forex.domain
 
-case class Rate(
+final case class Rate(
     pair: Rate.Pair,
     price: Price,
     timestamp: Timestamp
@@ -8,7 +8,7 @@ case class Rate(
 
 object Rate {
   final case class Pair(
-      from: Currency,
-      to: Currency
+      from: Currency.Currency,
+      to: Currency.Currency
   )
 }
diff --git a/forex-mtl/src/main/scala/forex/domain/Timestamp.scala b/forex-mtl/src/main/scala/forex/domain/Timestamp.scala
index 82fc3fb0..accc53ca 100644
--- a/forex-mtl/src/main/scala/forex/domain/Timestamp.scala
+++ b/forex-mtl/src/main/scala/forex/domain/Timestamp.scala
@@ -2,7 +2,7 @@ package forex.domain
 
 import java.time.OffsetDateTime
 
-case class Timestamp(value: OffsetDateTime) extends AnyVal
+final case class Timestamp(value: OffsetDateTime) extends AnyVal
 
 object Timestamp {
   def now: Timestamp =
diff --git a/forex-mtl/src/main/scala/forex/http/rates/Protocol.scala b/forex-mtl/src/main/scala/forex/http/rates/Protocol.scala
index 75391f9d..7b4bc901 100644
--- a/forex-mtl/src/main/scala/forex/http/rates/Protocol.scala
+++ b/forex-mtl/src/main/scala/forex/http/rates/Protocol.scala
@@ -1,7 +1,6 @@
 package forex.http
 package rates
 
-import forex.domain.Currency.show
 import forex.domain.Rate.Pair
 import forex.domain._
 import io.circe._
@@ -13,19 +12,25 @@ object Protocol {
   implicit val configuration: Configuration = Configuration.default.withSnakeCaseMemberNames
 
   final case class GetApiRequest(
-      from: Currency,
-      to: Currency
+      from: Currency.Currency,
+      to: Currency.Currency
   )
 
   final case class GetApiResponse(
-      from: Currency,
-      to: Currency,
+      from: Currency.Currency,
+      to: Currency.Currency,
       price: Price,
       timestamp: Timestamp
   )
 
-  implicit val currencyEncoder: Encoder[Currency] =
-    Encoder.instance[Currency] { show.show _ andThen Json.fromString }
+  final case class ErrorApiResponse(
+      error: String,
+      message: String,
+      timestamp: String
+  )
+
+  implicit val currencyEncoder: Encoder[Currency.Currency] =
+    Encoder.instance[Currency.Currency] { c => Json.fromString(c.toString) }
 
   implicit val pairEncoder: Encoder[Pair] =
     deriveConfiguredEncoder[Pair]
@@ -36,4 +41,7 @@ object Protocol {
   implicit val responseEncoder: Encoder[GetApiResponse] =
     deriveConfiguredEncoder[GetApiResponse]
 
+  implicit val errorResponseEncoder: Encoder[ErrorApiResponse] =
+    deriveConfiguredEncoder[ErrorApiResponse]
+
 }
diff --git a/forex-mtl/src/main/scala/forex/http/rates/QueryParams.scala b/forex-mtl/src/main/scala/forex/http/rates/QueryParams.scala
index b19ed4ce..83536867 100644
--- a/forex-mtl/src/main/scala/forex/http/rates/QueryParams.scala
+++ b/forex-mtl/src/main/scala/forex/http/rates/QueryParams.scala
@@ -1,15 +1,16 @@
 package forex.http.rates
 
 import forex.domain.Currency
-import org.http4s.QueryParamDecoder
+import org.http4s.{QueryParamDecoder, ParseFailure}
 import org.http4s.dsl.impl.QueryParamDecoderMatcher
 
 object QueryParams {
 
-  private[http] implicit val currencyQueryParam: QueryParamDecoder[Currency] =
-    QueryParamDecoder[String].map(Currency.fromString)
+  private[http] implicit val currencyQueryParam: QueryParamDecoder[Currency.Currency] =
+    QueryParamDecoder[String].emap(s => 
+      Currency.fromString(s).toRight(ParseFailure(s"Invalid currency: $s", s)))
 
-  object FromQueryParam extends QueryParamDecoderMatcher[Currency]("from")
-  object ToQueryParam extends QueryParamDecoderMatcher[Currency]("to")
+  object FromQueryParam extends QueryParamDecoderMatcher[Currency.Currency]("from")
+  object ToQueryParam extends QueryParamDecoderMatcher[Currency.Currency]("to")
 
 }
diff --git a/forex-mtl/src/main/scala/forex/http/rates/RatesHttpRoutes.scala b/forex-mtl/src/main/scala/forex/http/rates/RatesHttpRoutes.scala
index d91dcffb..49749d9d 100644
--- a/forex-mtl/src/main/scala/forex/http/rates/RatesHttpRoutes.scala
+++ b/forex-mtl/src/main/scala/forex/http/rates/RatesHttpRoutes.scala
@@ -3,22 +3,62 @@ package rates
 
 import cats.effect.Sync
 import cats.syntax.flatMap._
+import forex.domain.Currency
 import forex.programs.RatesProgram
-import forex.programs.rates.{ Protocol => RatesProgramProtocol }
-import org.http4s.HttpRoutes
+import forex.programs.rates.{Protocol => RatesProgramProtocol}
+import forex.programs.rates.errors.Error
+import org.http4s.{HttpRoutes, Status}
 import org.http4s.dsl.Http4sDsl
 import org.http4s.server.Router
+import org.slf4j.LoggerFactory
+
+import java.time.Instant
 
 class RatesHttpRoutes[F[_]: Sync](rates: RatesProgram[F]) extends Http4sDsl[F] {
 
   import Converters._, QueryParams._, Protocol._
+  
+  private val logger = LoggerFactory.getLogger(classOf[RatesHttpRoutes[F]])
 
   private[http] val prefixPath = "/rates"
 
   private val httpRoutes: HttpRoutes[F] = HttpRoutes.of[F] {
     case GET -> Root :? FromQueryParam(from) +& ToQueryParam(to) =>
-      rates.get(RatesProgramProtocol.GetRatesRequest(from, to)).flatMap(Sync[F].fromEither).flatMap { rate =>
-        Ok(rate.asGetApiResponse)
+      rates.get(RatesProgramProtocol.GetRatesRequest(from, to)).flatMap {
+        case Right(rate) => 
+          Ok(rate.asGetApiResponse)
+        case Left(error: Error) =>
+          Sync[F].delay(logger.warn(s"API request failed: GET /rates?from=$from&to=$to - ${error.message}")).flatMap { _ =>
+            val errorResponse = ErrorApiResponse(
+              error = error.errorCode,
+              message = error.message,
+              timestamp = Instant.now().toString
+            )
+            Status.fromInt(error.httpStatusCode) match {
+              case Right(status) => 
+                Sync[F].pure(org.http4s.Response[F](status).withEntity(errorResponse))
+              case Left(_) => 
+                InternalServerError(errorResponse)
+            }
+          }
+      }
+    case req @ GET -> Root if req.uri.query.nonEmpty =>
+      Sync[F].delay(logger.warn(s"Invalid currency parameters in request: ${req.uri.query}")).flatMap { _ =>
+        val errorResponse = ErrorApiResponse(
+          error = "INVALID_PARAMETERS",
+          message = "Invalid currency parameters. Supported currencies: " + Currency.allCurrencies.mkString(", "),
+          timestamp = Instant.now().toString
+        )
+        BadRequest(errorResponse)
+      }
+    case GET -> Root =>
+      Sync[F].delay(logger.warn("Missing required parameters 'from' and 'to' in /rates request")).flatMap { _ =>
+        val errorResponse = ErrorApiResponse(
+          error = "MISSING_PARAMETERS",
+          message = "Missing required parameters: 'from' and 'to'",
+          timestamp = Instant.now().toString
+        )
+        BadRequest(errorResponse)
       }
   }
 
diff --git a/forex-mtl/src/main/scala/forex/programs/rates/Protocol.scala b/forex-mtl/src/main/scala/forex/programs/rates/Protocol.scala
index 7ceae75d..f0b2f2b6 100644
--- a/forex-mtl/src/main/scala/forex/programs/rates/Protocol.scala
+++ b/forex-mtl/src/main/scala/forex/programs/rates/Protocol.scala
@@ -5,8 +5,8 @@ import forex.domain.Currency
 object Protocol {
 
   final case class GetRatesRequest(
-      from: Currency,
-      to: Currency
+      from: Currency.Currency,
+      to: Currency.Currency
   )
 
 }
diff --git a/forex-mtl/src/main/scala/forex/programs/rates/errors.scala b/forex-mtl/src/main/scala/forex/programs/rates/errors.scala
index 39496b13..3a53192c 100644
--- a/forex-mtl/src/main/scala/forex/programs/rates/errors.scala
+++ b/forex-mtl/src/main/scala/forex/programs/rates/errors.scala
@@ -4,12 +4,36 @@ import forex.services.rates.errors.{ Error => RatesServiceError }
 
 object errors {
 
-  sealed trait Error extends Exception
+  sealed trait Error extends Exception {
+    def message: String
+    def errorCode: String
+    def httpStatusCode: Int
+  }
+  
   object Error {
-    final case class RateLookupFailed(msg: String) extends Error
+    final case class RateLookupFailed(msg: String, code: String, httpStatus: Int = 500) extends Error {
+      val message: String = msg
+      val errorCode: String = code
+      val httpStatusCode: Int = httpStatus
+    }
   }
 
   def toProgramError(error: RatesServiceError): Error = error match {
-    case RatesServiceError.OneFrameLookupFailed(msg) => Error.RateLookupFailed(msg)
+    case RatesServiceError.OneFrameLookupFailed(msg) => 
+      Error.RateLookupFailed(msg, "ONEFRAME_LOOKUP_FAILED", 500)
+    case RatesServiceError.NetworkError(msg, _) => 
+      Error.RateLookupFailed(msg, "NETWORK_ERROR", 502)
+    case RatesServiceError.AuthenticationError(msg) => 
+      Error.RateLookupFailed(msg, "AUTHENTICATION_ERROR", 500)
+    case RatesServiceError.RateNotFound(pair) => 
+      Error.RateLookupFailed(s"Rate not found for currency pair: $pair", "RATE_NOT_FOUND", 404)
+    case RatesServiceError.InvalidResponse(msg) => 
+      Error.RateLookupFailed(msg, "INVALID_RESPONSE", 502)
+    case RatesServiceError.ServiceUnavailable(msg) => 
+      Error.RateLookupFailed(msg, "SERVICE_UNAVAILABLE", 503)
+    case RatesServiceError.RateLimitExceeded(msg) => 
+      Error.RateLookupFailed(msg, "RATE_LIMIT_EXCEEDED", 429)
+    case RatesServiceError.InvalidCurrencyPair(pair, reason) => 
+      Error.RateLookupFailed(s"Invalid currency pair $pair: $reason", "INVALID_CURRENCY_PAIR", 400)
   }
 }
diff --git a/forex-mtl/src/main/scala/forex/services/rates/Interpreters.scala b/forex-mtl/src/main/scala/forex/services/rates/Interpreters.scala
index e523ffab..40fa39f0 100644
--- a/forex-mtl/src/main/scala/forex/services/rates/Interpreters.scala
+++ b/forex-mtl/src/main/scala/forex/services/rates/Interpreters.scala
@@ -1,8 +1,14 @@
 package forex.services.rates
 
-import cats.Applicative
+import cats.effect.{Clock, ConcurrentEffect}
+import forex.config.{CacheConfig, OneFrameConfig}
 import interpreters._
+import scala.concurrent.ExecutionContext
 
 object Interpreters {
-  def dummy[F[_]: Applicative]: Algebra[F] = new OneFrameDummy[F]()
+  def cachedOneFrame[F[_]: ConcurrentEffect: Clock](
+      oneFrameConfig: OneFrameConfig, 
+      cacheConfig: CacheConfig
+  )(implicit ec: ExecutionContext): Algebra[F] = 
+    CachedOneFrame[F](oneFrameConfig, cacheConfig)
 }
diff --git a/forex-mtl/src/main/scala/forex/services/rates/RateCache.scala b/forex-mtl/src/main/scala/forex/services/rates/RateCache.scala
new file mode 100644
index 00000000..be31334a
--- /dev/null
+++ b/forex-mtl/src/main/scala/forex/services/rates/RateCache.scala
@@ -0,0 +1,57 @@
+package forex.services.rates
+
+import cats.effect.{Clock, Sync}
+import cats.implicits.toFlatMapOps
+import cats.syntax.functor._
+import forex.config.CacheConfig
+import forex.domain.Rate
+import org.slf4j.LoggerFactory
+
+import java.time.Instant
+import java.util.concurrent.TimeUnit.MILLISECONDS
+import scala.collection.concurrent.TrieMap
+
+final case class CachedRate(rate: Rate, expiresAt: Instant)
+
+class RateCache[F[_]: Sync: Clock](config: CacheConfig) {
+  
+  private val cache = TrieMap[Rate.Pair, CachedRate]()
+  private val ttl = config.ttl
+  private val logger = LoggerFactory.getLogger(classOf[RateCache[F]])
+
+  def get(pair: Rate.Pair): F[Option[Rate]] = {
+    Clock[F].realTime(MILLISECONDS).map { nowMillis =>
+      cache.get(pair).flatMap { cachedRate =>
+        if (cachedRate.expiresAt.isAfter(Instant.ofEpochMilli(nowMillis))) {
+          logger.info(s"Cache HIT for ${pair.from}${pair.to}")
+          Some(cachedRate.rate)
+        } else {
+          logger.info(s"Cache OUTDATED for ${pair.from}${pair.to}. Now: ${Instant.ofEpochMilli(nowMillis)}, expires at: ${cachedRate.expiresAt}")
+          cache.remove(pair)
+          None
+        }
+      }
+    }
+  }
+
+  def put(rate: Rate): F[Unit] = {
+    putBatch(List(rate))
+  }
+
+  def clear(): F[Unit] = Sync[F].delay(cache.clear())
+  
+  def getAllCachedPairs: F[List[Rate.Pair]] = {
+    Sync[F].delay(cache.keys.toList)
+  }
+  
+  def putBatch(rates: List[Rate]): F[Unit] = {
+    Clock[F].realTime(MILLISECONDS).flatMap { nowMillis =>
+      Sync[F].delay {
+        val expiresAt = Instant.ofEpochMilli(nowMillis).plusMillis(ttl.toMillis)
+        rates.foreach { rate =>
+          cache.put(rate.pair, CachedRate(rate, expiresAt))
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/main/scala/forex/services/rates/algebra.scala b/forex-mtl/src/main/scala/forex/services/rates/algebra.scala
index 8966dce5..d0ce5404 100644
--- a/forex-mtl/src/main/scala/forex/services/rates/algebra.scala
+++ b/forex-mtl/src/main/scala/forex/services/rates/algebra.scala
@@ -3,6 +3,17 @@ package forex.services.rates
 import forex.domain.Rate
 import errors._
 
+import cats.Applicative
+import cats.implicits._
+
 trait Algebra[F[_]] {
   def get(pair: Rate.Pair): F[Error Either Rate]
+  
+  def getBatch(pairs: List[Rate.Pair])(implicit F: Applicative[F]): F[Error Either List[Rate]] = {
+    pairs.traverse(get).map { results =>
+      val (errors, rates) = results.separate
+      if (errors.isEmpty) rates.asRight[Error]
+      else errors.head.asLeft[List[Rate]]
+    }
+  }
 }
diff --git a/forex-mtl/src/main/scala/forex/services/rates/errors.scala b/forex-mtl/src/main/scala/forex/services/rates/errors.scala
index 0584dcf4..9acf20e1 100644
--- a/forex-mtl/src/main/scala/forex/services/rates/errors.scala
+++ b/forex-mtl/src/main/scala/forex/services/rates/errors.scala
@@ -2,9 +2,51 @@ package forex.services.rates
 
 object errors {
 
-  sealed trait Error
+  sealed trait Error {
+    def message: String
+    def errorCode: String
+  }
+  
   object Error {
-    final case class OneFrameLookupFailed(msg: String) extends Error
+    final case class OneFrameLookupFailed(msg: String) extends Error {
+      val message: String = msg
+      val errorCode: String = "ONEFRAME_LOOKUP_FAILED"
+    }
+    
+    final case class NetworkError(msg: String, cause: Option[Throwable] = None) extends Error {
+      val message: String = s"Network error: $msg"
+      val errorCode: String = "NETWORK_ERROR"
+    }
+    
+    final case class AuthenticationError(msg: String) extends Error {
+      val message: String = s"Authentication failed: $msg"
+      val errorCode: String = "AUTHENTICATION_ERROR"  
+    }
+    
+    final case class RateNotFound(pair: String) extends Error {
+      val message: String = s"Rate not found for currency pair: $pair"
+      val errorCode: String = "RATE_NOT_FOUND"
+    }
+    
+    final case class InvalidResponse(msg: String) extends Error {
+      val message: String = s"Invalid response from provider: $msg"
+      val errorCode: String = "INVALID_RESPONSE"
+    }
+    
+    final case class ServiceUnavailable(msg: String) extends Error {
+      val message: String = s"External service unavailable: $msg"  
+      val errorCode: String = "SERVICE_UNAVAILABLE"
+    }
+    
+    final case class RateLimitExceeded(msg: String) extends Error {
+      val message: String = s"Rate limit exceeded: $msg"
+      val errorCode: String = "RATE_LIMIT_EXCEEDED"
+    }
+    
+    final case class InvalidCurrencyPair(pair: String, reason: String) extends Error {
+      val message: String = s"Invalid currency pair $pair: $reason"
+      val errorCode: String = "INVALID_CURRENCY_PAIR"
+    }
   }
 
 }
diff --git a/forex-mtl/src/main/scala/forex/services/rates/interpreters/CachedOneFrame.scala b/forex-mtl/src/main/scala/forex/services/rates/interpreters/CachedOneFrame.scala
new file mode 100644
index 00000000..5b81699f
--- /dev/null
+++ b/forex-mtl/src/main/scala/forex/services/rates/interpreters/CachedOneFrame.scala
@@ -0,0 +1,97 @@
+package forex.services.rates.interpreters
+
+import cats.effect.{Clock, ConcurrentEffect}
+import cats.syntax.either._
+import cats.syntax.flatMap._
+import forex.config.{CacheConfig, OneFrameConfig}
+import forex.domain.Rate
+import forex.services.rates.errors.Error.{InvalidCurrencyPair, RateNotFound}
+import forex.services.rates.{Algebra, RateCache}
+import forex.services.rates.errors._
+import org.slf4j.LoggerFactory
+
+import scala.concurrent.ExecutionContext
+
+class CachedOneFrame[F[_]: ConcurrentEffect](
+    client: Algebra[F],
+    cache: RateCache[F]
+) extends Algebra[F] {
+
+  private val logger = LoggerFactory.getLogger(classOf[CachedOneFrame[F]])
+
+  private def validateCurrencyPair(pair: Rate.Pair): Either[Error, Rate.Pair] = {
+    val pairStr = s"${pair.from}${pair.to}"
+    
+    if (pair.from == pair.to) {
+      Left(InvalidCurrencyPair(pairStr, "same currency conversion not supported"))
+    } else {
+      Right(pair)
+    }
+  }
+
+  override def get(pair: Rate.Pair): F[Error Either Rate] = {
+    validateCurrencyPair(pair) match {
+      case Left(error) =>
+        logger.warn(s"Invalid currency pair validation failed: ${error.message}")
+        ConcurrentEffect[F].pure(error.asLeft[Rate])
+      case Right(validPair) =>
+        getCurrencyRate(validPair)
+    }
+  }
+
+  private def getCurrencyRate(pair: Rate.Pair): F[Error Either Rate] = {
+    cache.get(pair).flatMap {
+      case Some(cachedRate) =>
+        logger.debug(s"Cache HIT for ${pair.from}${pair.to} (unsynchronized read)")
+        ConcurrentEffect[F].pure(cachedRate.asRight[Error])
+      case None =>
+        this.synchronized {
+          cache.get(pair).flatMap {
+            case Some(cachedRate) =>
+              logger.debug(s"Cache HIT for ${pair.from}${pair.to} (synchronized double-check)")
+              ConcurrentEffect[F].pure(cachedRate.asRight[Error])
+            case None =>
+              logger.debug(s"Cache MISS for ${pair.from}${pair.to} (confirmed after double-check)")
+              performBatchAPICall(pair)
+          }
+        }
+    }
+  }
+
+  private def performBatchAPICall(pair: Rate.Pair): F[Error Either Rate] = {
+    cache.getAllCachedPairs.flatMap { allCachedPairs =>
+      val pairsToFetch = (allCachedPairs :+ pair).distinct
+      val pairsStr = pairsToFetch.map(p => s"${p.from}${p.to}").mkString(", ")
+      logger.info(s"Batch request for ALL pairs: [$pairsStr]")
+      
+      client.getBatch(pairsToFetch).flatMap {
+        case Right(rates) =>
+          cache.putBatch(rates).flatMap { _ =>
+            rates.find(_.pair == pair) match {
+              case Some(rate) => 
+                ConcurrentEffect[F].pure(rate.asRight[Error])
+              case None => 
+                val pairStr = s"${pair.from}${pair.to}"
+                logger.warn(s"Requested pair $pairStr not found in batch response")
+                ConcurrentEffect[F].pure(RateNotFound(pairStr).asLeft[Rate])
+            }
+          }
+        case Left(error) =>
+          logger.error(s"Batch API call failed: $error")
+          ConcurrentEffect[F].pure(error.asLeft[Rate])
+      }
+    }
+  }
+
+}
+
+object CachedOneFrame {
+  def apply[F[_]: ConcurrentEffect: Clock](
+      oneFrameConfig: OneFrameConfig, 
+      cacheConfig: CacheConfig
+  )(implicit ec: ExecutionContext): CachedOneFrame[F] = {
+    val client = new OneFrameClient[F](oneFrameConfig)
+    val cache = new RateCache[F](cacheConfig)
+    new CachedOneFrame[F](client, cache)
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/main/scala/forex/services/rates/interpreters/OneFrameClient.scala b/forex-mtl/src/main/scala/forex/services/rates/interpreters/OneFrameClient.scala
new file mode 100644
index 00000000..1d8bed96
--- /dev/null
+++ b/forex-mtl/src/main/scala/forex/services/rates/interpreters/OneFrameClient.scala
@@ -0,0 +1,148 @@
+package forex.services.rates.interpreters
+
+import cats.effect.{ConcurrentEffect, Sync}
+import cats.implicits.{catsSyntaxApplicativeError, toFlatMapOps}
+import cats.syntax.either._
+import cats.syntax.functor._
+import forex.domain.{Currency, Price, Rate, Timestamp}
+import forex.services.rates.Algebra
+import forex.services.rates.errors.Error.{AuthenticationError, InvalidResponse, NetworkError, RateNotFound, RateLimitExceeded, ServiceUnavailable}
+import forex.services.rates.errors._
+import io.circe.generic.auto._
+import org.http4s.circe.CirceEntityDecoder._
+import org.http4s.blaze.client.BlazeClientBuilder
+import org.http4s.{Header, Headers, Method, Request, Uri}
+import org.slf4j.LoggerFactory
+import org.typelevel.ci._
+
+import forex.config.OneFrameConfig
+import java.time.OffsetDateTime
+import scala.concurrent.ExecutionContext
+
+final case class OneFrameResponse(
+    from: String,
+    to: String,
+    price: BigDecimal,
+    time_stamp: String
+)
+
+class OneFrameClient[F[_]: ConcurrentEffect](config: OneFrameConfig)(implicit ec: ExecutionContext) extends Algebra[F] {
+
+  private val logger = LoggerFactory.getLogger(classOf[OneFrameClient[F]])
+  
+  def checkTimeSync(timestamp: String): Unit = {
+    try {
+      val apiTimestamp = OffsetDateTime.parse(timestamp)
+      val now = OffsetDateTime.now()
+      val timeDiff = java.time.Duration.between(now, apiTimestamp)
+      val absDiff = timeDiff.abs()
+      
+      if (absDiff.compareTo(java.time.Duration.ofSeconds(config.timeTolerance.toSeconds)) > 0) {
+        val direction = if (timeDiff.isNegative) "behind" else "ahead"
+        logger.warn(s"Time synchronization issue detected: API timestamp $timestamp is ${absDiff.getSeconds}s $direction of server time $now (tolerance: ${config.timeTolerance.toSeconds}s)")
+      }
+    } catch {
+      case ex: Exception =>
+        logger.warn(s"Invalid timestamp format from API: $timestamp - ${ex.getMessage}")
+    }
+  }
+  
+  def buildBatchUrl(pairs: List[Rate.Pair]): String = {
+    val pairStrings = pairs.map(p => s"${p.from}${p.to}")
+    val queryString = pairStrings.map(p => s"pair=$p").mkString("&")
+    s"${config.url}$queryString"
+  }
+
+  override def getBatch(pairs: List[Rate.Pair])(implicit ev: cats.Applicative[F]): F[Error Either List[Rate]] = {
+    val logInfo = (msg: String) => Sync[F].delay(logger.info(msg))
+    if (pairs.isEmpty) {
+      logInfo("Empty batch request, returning empty list").flatMap { _ =>
+        ConcurrentEffect[F].pure(List.empty[Rate].asRight[Error])
+      }
+    } else {
+      val pairsStr = pairs.map(p => s"${p.from}${p.to}").mkString(", ")
+      val uriString = buildBatchUrl(pairs)
+      val uri = Uri.unsafeFromString(uriString)
+      
+      logInfo(s"Making batch HTTP request for pairs: [$pairsStr]").flatMap { _ =>
+        BlazeClientBuilder[F](ec).resource.use { client =>
+          val request = Request[F](
+            method = Method.GET,
+            uri = uri,
+            headers = Headers.apply(Header.Raw.apply(name = ci"token", value = config.token))
+          )
+
+          client.expect[List[OneFrameResponse]](request).map { responses =>
+            val rates = responses.flatMap { response =>
+              checkTimeSync(response.time_stamp)
+              for {
+                fromCurrency <- Currency.fromString(response.from)
+                toCurrency <- Currency.fromString(response.to)
+              } yield Rate(
+                Rate.Pair(fromCurrency, toCurrency),
+                Price(response.price),
+                Timestamp(OffsetDateTime.parse(response.time_stamp))
+              )
+            }
+            if (responses.isEmpty) {
+              logger.warn(s"Empty response from One-Frame for pairs [$pairsStr] - possibly same currency pairs or unsupported pairs")
+            } else if (responses.length < pairs.length) {
+              val returnedPairs = rates.map(r => s"${r.pair.from}${r.pair.to}").mkString(", ")
+              logger.warn(s"Partial response from One-Frame: requested ${pairs.length} pairs [$pairsStr], received ${responses.length} rates [$returnedPairs]")
+            } else {
+              logger.debug(s"Batch request successful: received ${rates.length} rates")
+            }
+            rates.asRight[Error]
+          }.handleError { ex =>
+
+            val errorMessage = ex.getMessage
+            
+            ex match {
+              case _: java.net.ConnectException =>
+                logger.error(s"Connection failed for pairs [$pairsStr]: $errorMessage", ex)
+                (NetworkError(s"Unable to connect to OneFrame service", Some(ex)): Error).asLeft[List[Rate]]
+              case _: java.net.SocketTimeoutException =>
+                logger.error(s"Request timeout for pairs [$pairsStr]: $errorMessage", ex)
+                (NetworkError(s"Request timeout", Some(ex)): Error).asLeft[List[Rate]]
+              case _ if errorMessage.contains("Forbidden") =>
+                logger.error(s"Authentication failed for pairs [$pairsStr]: $errorMessage")
+                (AuthenticationError("Invalid or expired token"): Error).asLeft[List[Rate]]
+              case _ if errorMessage.contains("No currency pair provided") =>
+                logger.error(s"Invalid request for pairs [$pairsStr]: $errorMessage")
+                (InvalidResponse("No currency pair provided in request"): Error).asLeft[List[Rate]]
+              case _ if errorMessage.contains("Invalid Currency Pair") =>
+                logger.error(s"Invalid currency pair for pairs [$pairsStr]: $errorMessage")
+                (RateNotFound(pairsStr): Error).asLeft[List[Rate]]
+              case _ if errorMessage.contains("Quota reached") =>
+                logger.error(s"Rate limit exceeded for pairs [$pairsStr]: $errorMessage")
+                (RateLimitExceeded("Daily quota exceeded"): Error).asLeft[List[Rate]]
+              case _ if errorMessage.contains("404") =>
+                logger.error(s"Endpoint not found for pairs [$pairsStr]: $errorMessage")
+                (ServiceUnavailable("OneFrame service endpoint not found"): Error).asLeft[List[Rate]]
+              case _ if errorMessage.contains("503") =>
+                logger.error(s"Service unavailable for pairs [$pairsStr]: $errorMessage")
+                (ServiceUnavailable("OneFrame service temporarily unavailable"): Error).asLeft[List[Rate]]
+              case _ =>
+                logger.error(s"Batch request failed for pairs [$pairsStr]: $errorMessage", ex)
+                (NetworkError(s"Request failed: $errorMessage", Some(ex)): Error).asLeft[List[Rate]]
+            }
+          }
+        }
+      }
+    }
+  }
+
+  override def get(pair: Rate.Pair): F[Error Either Rate] = {
+    getBatch(List(pair)).map {
+      case Right(rates) => 
+        rates.headOption match {
+          case Some(rate) => rate.asRight[Error]
+          case None => 
+            val pairStr = s"${pair.from}${pair.to}"
+            logger.warn(s"No rate found in API response for pair: $pairStr")
+            (RateNotFound(pairStr): Error).asLeft[Rate]
+        }
+      case Left(error) => error.asLeft[Rate]
+    }
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/main/scala/forex/services/rates/interpreters/OneFrameDummy.scala b/forex-mtl/src/main/scala/forex/services/rates/interpreters/OneFrameDummy.scala
deleted file mode 100644
index 37a3f50c..00000000
--- a/forex-mtl/src/main/scala/forex/services/rates/interpreters/OneFrameDummy.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-package forex.services.rates.interpreters
-
-import forex.services.rates.Algebra
-import cats.Applicative
-import cats.syntax.applicative._
-import cats.syntax.either._
-import forex.domain.{ Price, Rate, Timestamp }
-import forex.services.rates.errors._
-
-class OneFrameDummy[F[_]: Applicative] extends Algebra[F] {
-
-  override def get(pair: Rate.Pair): F[Error Either Rate] =
-    Rate(pair, Price(BigDecimal(100)), Timestamp.now).asRight[Error].pure[F]
-
-}
diff --git a/forex-mtl/src/test/scala/forex/helpers/MockAlgebra.scala b/forex-mtl/src/test/scala/forex/helpers/MockAlgebra.scala
new file mode 100644
index 00000000..eb26bcd5
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/helpers/MockAlgebra.scala
@@ -0,0 +1,96 @@
+package forex.helpers
+
+import cats.Applicative
+import cats.effect.Sync
+import cats.syntax.either._
+import forex.domain.Rate
+import forex.services.rates.Algebra
+import forex.services.rates.errors.Error
+import forex.services.rates.errors.Error.OneFrameLookupFailed
+
+import scala.collection.mutable
+
+class MockAlgebra[F[_]: Sync](testClock: Option[TestClock[F]] = None) extends Algebra[F] {
+  private var _callCount = 0
+  private var _batchCallCount = 0
+  private val _calledPairs = mutable.ListBuffer[Rate.Pair]()
+  private val _batchCalledPairs = mutable.ListBuffer[List[Rate.Pair]]()
+  private var _expectedBatchPairs: Option[List[Rate.Pair]] = None
+  private var _shouldFail = false
+  private var _batchShouldFail = false
+  
+  def callCount: Int = _callCount
+  def batchCallCount: Int = _batchCallCount
+  def calledPairs: List[Rate.Pair] = _calledPairs.toList
+  def batchCalledPairs: List[List[Rate.Pair]] = _batchCalledPairs.toList
+  
+  def expectBatchCall(pairs: List[Rate.Pair]): Unit = {
+    _expectedBatchPairs = Some(pairs)
+  }
+  
+  def setShouldFail(fail: Boolean): Unit = {
+    _shouldFail = fail
+  }
+  
+  def setBatchShouldFail(fail: Boolean): Unit = {
+    _batchShouldFail = fail
+  }
+  
+  def reset(): Unit = {
+    _callCount = 0
+    _batchCallCount = 0
+    _calledPairs.clear()
+    _batchCalledPairs.clear()
+    _expectedBatchPairs = None
+    _shouldFail = false
+    _batchShouldFail = false
+  }
+  
+  override def get(pair: Rate.Pair): F[Error Either Rate] = {
+    _callCount += 1
+    _calledPairs += pair
+    
+    if (_shouldFail) {
+      Sync[F].pure(OneFrameLookupFailed("Mock failure").asLeft[Rate])
+    } else {
+      val rate = testClock match {
+        case Some(clock) => TestData.createTestRateWithClock(pair.from, pair.to, clock)
+        case None => TestData.createTestRate(pair.from, pair.to)
+      }
+      Sync[F].pure(rate.asRight[Error])
+    }
+  }
+  
+  override def getBatch(pairs: List[Rate.Pair])(implicit F: Applicative[F]): F[Error Either List[Rate]] = {
+    _batchCallCount += 1
+    _batchCalledPairs += pairs
+    
+    _expectedBatchPairs.foreach { expected =>
+      assert(pairs.toSet == expected.toSet, s"Expected batch call with $expected, but got $pairs")
+    }
+    
+    if (_batchShouldFail) {
+      Sync[F].pure(OneFrameLookupFailed("Mock batch failure").asLeft[List[Rate]])
+    } else {
+      val rates = pairs.map { pair =>
+        testClock match {
+          case Some(clock) => TestData.createTestRateWithClock(pair.from, pair.to, clock)
+          case None => TestData.createTestRate(pair.from, pair.to)
+        }
+      }
+      Sync[F].pure(rates.asRight[Error])
+    }
+  }
+  
+  def verifyBatchCalled(): Unit = {
+    assert(_batchCallCount > 0, "Expected batch call but none was made")
+  }
+  
+  def verifyBatchNotCalled(): Unit = {
+    assert(_batchCallCount == 0, s"Expected no batch calls but ${_batchCallCount} were made")
+  }
+  
+  def verifySingleCallCount(expected: Int): Unit = {
+    assert(_callCount == expected, s"Expected $expected single calls but got ${_callCount}")
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/helpers/TestClock.scala b/forex-mtl/src/test/scala/forex/helpers/TestClock.scala
new file mode 100644
index 00000000..35d05a96
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/helpers/TestClock.scala
@@ -0,0 +1,48 @@
+package forex.helpers
+
+import cats.effect.{Clock, Sync}
+import cats.syntax.applicative._
+
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicLong
+import scala.concurrent.duration.FiniteDuration
+
+class TestClock[F[_]: Sync] extends Clock[F] {
+  private val currentTimeMillis = new AtomicLong(System.currentTimeMillis())
+  
+  override def realTime(unit: TimeUnit): F[Long] = {
+    val millis = currentTimeMillis.get()
+    unit match {
+      case TimeUnit.MILLISECONDS => millis.pure[F]
+      case TimeUnit.SECONDS => (millis / 1000).pure[F]
+      case TimeUnit.MINUTES => (millis / (1000 * 60)).pure[F]
+      case TimeUnit.HOURS => (millis / (1000 * 60 * 60)).pure[F]
+      case TimeUnit.DAYS => (millis / (1000 * 60 * 60 * 24)).pure[F]
+      case TimeUnit.NANOSECONDS => (millis * 1000000).pure[F]
+      case TimeUnit.MICROSECONDS => (millis * 1000).pure[F]
+    }
+  }
+  
+  override def monotonic(unit: TimeUnit): F[Long] = realTime(unit)
+  
+  def advance(duration: FiniteDuration): Unit = {
+    currentTimeMillis.addAndGet(duration.toMillis)
+    ()
+  }
+  
+  def setTime(timeMillis: Long): Unit = {
+    currentTimeMillis.set(timeMillis)
+  }
+  
+  def currentTime: Long = currentTimeMillis.get()
+}
+
+object TestClock {
+  def apply[F[_]: Sync]: TestClock[F] = new TestClock[F]
+  
+  def withFixedTime[F[_]: Sync](timeMillis: Long): TestClock[F] = {
+    val clock = new TestClock[F]
+    clock.setTime(timeMillis)
+    clock
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/helpers/TestData.scala b/forex-mtl/src/test/scala/forex/helpers/TestData.scala
new file mode 100644
index 00000000..9ff1bc5d
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/helpers/TestData.scala
@@ -0,0 +1,41 @@
+package forex.helpers
+
+import forex.domain.{Currency, Price, Rate, Timestamp}
+import java.time.{Instant, OffsetDateTime}
+import scala.concurrent.duration._
+
+object TestData {
+  
+  def createTestRate(from: Currency.Currency, to: Currency.Currency, price: BigDecimal = 1.0): Rate = {
+    Rate(
+      Rate.Pair(from, to),
+      Price(price),
+      Timestamp(OffsetDateTime.now(java.time.ZoneOffset.UTC))
+    )
+  }
+  
+  def createTestRateWithClock[F[_]](from: Currency.Currency, to: Currency.Currency, testClock: TestClock[F], price: BigDecimal = 1.0): Rate = {
+    val timestamp = Instant.ofEpochMilli(testClock.currentTime).atOffset(java.time.ZoneOffset.UTC)
+    Rate(
+      Rate.Pair(from, to),
+      Price(price),
+      Timestamp(timestamp)
+    )
+  }
+  
+  def createExpiredRate(from: Currency.Currency, to: Currency.Currency, price: BigDecimal = 1.0): Rate = {
+    Rate(
+      Rate.Pair(from, to),
+      Price(price),
+      Timestamp(OffsetDateTime.now(java.time.ZoneOffset.UTC).minusMinutes(10))
+    )
+  }
+  
+  val testPairs = Currency.supportedPairs.take(5).map { case (from, to) => Rate.Pair(from, to) }
+  
+  val defaultTestConfig = forex.config.ApplicationConfig(
+    http = forex.config.HttpConfig("localhost", 8085, 30.seconds),
+    oneFrame = forex.config.OneFrameConfig("http://localhost:8080", "test-token", 30.seconds),
+    cache = forex.config.CacheConfig(5.minutes)
+  )
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/integration/CachedOneFrameIntegrationSpec.scala b/forex-mtl/src/test/scala/forex/integration/CachedOneFrameIntegrationSpec.scala
new file mode 100644
index 00000000..355b461d
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/integration/CachedOneFrameIntegrationSpec.scala
@@ -0,0 +1,172 @@
+package forex.integration
+
+import cats.effect.{ContextShift, IO, Timer}
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import forex.config.CacheConfig
+import forex.domain.{Currency, Rate}
+import forex.helpers.{MockAlgebra, TestClock, TestData}
+import forex.services.rates.RateCache
+import forex.services.rates.interpreters.CachedOneFrame
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.concurrent.duration._
+
+class CachedOneFrameIntegrationSpec extends AnyFlatSpec with Matchers {
+  implicit val cs: ContextShift[IO] = IO.contextShift(global)
+  implicit val timer: Timer[IO] = IO.timer(global)
+
+  "CachedOneFrame Integration" should "optimize API calls with batching" in {
+    val testClock = TestClock[IO]
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(2.seconds))(implicitly, testClock)
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF)
+    )
+    
+    // Phase 1: Initial requests - should make 3 batch calls (each with single pair)
+    pairs.foreach { pair =>
+      service.get(pair).unsafeRunSync() shouldBe a[Right[_, _]]
+    }
+    mockClient.batchCallCount shouldBe 3
+    
+    // Phase 2: Immediate re-requests - should use cache
+    mockClient.reset()
+    pairs.foreach { pair =>
+      service.get(pair).unsafeRunSync() shouldBe a[Right[_, _]]
+    }
+    mockClient.batchCallCount shouldBe 0
+    
+    // Phase 3: After expiration - should make 1 batch call
+    testClock.advance(3.seconds) // Advance time beyond TTL
+    mockClient.reset()
+    
+    // Request first pair - should trigger batch for all expired tracked pairs
+    service.get(pairs.head).unsafeRunSync() shouldBe a[Right[_, _]]
+    
+    mockClient.batchCallCount shouldBe 1
+
+    // All pairs should now be cached again
+    pairs.foreach { pair =>
+      service.get(pair).unsafeRunSync() shouldBe a[Right[_, _]]
+    }
+    // Should still be only 1 batch call
+    mockClient.batchCallCount shouldBe 1
+  }
+  
+  it should "handle mixed cache states correctly" in {
+    val mockClient = new MockAlgebra[IO]
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val cachedPair = Rate.Pair(Currency.USD, Currency.EUR)
+    val uncachedPair = Rate.Pair(Currency.JPY, Currency.USD)
+    
+    // Pre-cache one pair
+    val cachedRate = TestData.createTestRate(cachedPair.from, cachedPair.to)
+    cache.put(cachedRate).unsafeRunSync()
+    
+    // Request both pairs
+    service.get(cachedPair).unsafeRunSync() shouldBe Right(cachedRate)
+    service.get(uncachedPair).unsafeRunSync() shouldBe a[Right[_, _]]
+    
+    // Should make only 1 batch API call - includes cached pair + uncached pair
+    mockClient.batchCallCount shouldBe 1
+    mockClient.batchCalledPairs should contain only List(cachedPair, uncachedPair)
+  }
+  
+  it should "recover from API failures and retry successfully" in {
+    val mockClient = new MockAlgebra[IO]
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    // Simulate API failure
+    mockClient.setBatchShouldFail(true)
+    val failedResult = service.get(pair).unsafeRunSync()
+    failedResult.isLeft shouldBe true
+    
+    // Fix API and retry
+    mockClient.setBatchShouldFail(false)
+    val successResult = service.get(pair).unsafeRunSync()
+    successResult.isRight shouldBe true
+    
+    mockClient.batchCallCount shouldBe 2
+  }
+  
+  it should "maintain performance under concurrent load" in {
+    val mockClient = new MockAlgebra[IO]
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    // Simulate concurrent requests
+    val futures = (1 to 100).map(_ => 
+      IO(service.get(pair).unsafeRunSync())
+    ).toList
+    
+    // All should complete
+    val results = futures.map(_.unsafeRunSync())
+    results.foreach(_ shouldBe a[Right[_, _]])
+    
+    // Should make only 1 batch API call despite 100 concurrent requests
+    mockClient.batchCallCount shouldBe 1
+  }
+  
+  it should "handle cache invalidation scenarios" in {
+    val mockClient = new MockAlgebra[IO]
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    // Initial request
+    service.get(pair).unsafeRunSync()
+    mockClient.batchCallCount shouldBe 1
+    
+    // Clear cache manually
+    cache.clear().unsafeRunSync()
+    
+    // Next request should hit API again (as tracked pair is expired)
+    service.get(pair).unsafeRunSync()
+    // Note: This will make batch call since tracked pair is now expired
+    mockClient.batchCallCount shouldBe 2
+  }
+  
+  it should "batch requests efficiently when multiple pairs expire simultaneously" in {
+    val testClock = TestClock[IO]
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(2.seconds))(implicitly, testClock)
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF),
+      Rate.Pair(Currency.AUD, Currency.CAD),
+      Rate.Pair(Currency.NZD, Currency.SGD)
+    )
+    
+    // Track all pairs by requesting them
+    pairs.foreach(service.get(_).unsafeRunSync())
+    
+    // Advance time to expire all pairs
+    testClock.advance(3.seconds)
+    mockClient.reset()
+    
+    // Request any pair - should batch all expired pairs
+    service.get(pairs.head).unsafeRunSync()
+    
+    mockClient.batchCallCount shouldBe 1
+
+    // Verify all pairs were included in the batch
+    mockClient.batchCalledPairs.head.toSet shouldBe pairs.toSet
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/performance/PerformanceSpec.scala b/forex-mtl/src/test/scala/forex/performance/PerformanceSpec.scala
new file mode 100644
index 00000000..128f08a0
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/performance/PerformanceSpec.scala
@@ -0,0 +1,136 @@
+package forex.performance
+
+import cats.effect.{ContextShift, IO, Timer}
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import forex.config.CacheConfig
+import forex.domain.{Currency, Rate}
+import forex.helpers.{MockAlgebra, TestClock}
+import forex.services.rates.RateCache
+import forex.services.rates.interpreters.CachedOneFrame
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.concurrent.duration._
+
+class PerformanceSpec extends AnyFlatSpec with Matchers {
+  implicit val cs: ContextShift[IO] = IO.contextShift(global)
+  implicit val timer: Timer[IO] = IO.timer(global)
+
+  "CachedOneFrame Performance" should "handle 1000 requests efficiently with caching" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    val requestCount = 1000
+    
+    // Make 1000 requests - should be fast with caching
+    (1 to requestCount).foreach { _ =>
+      service.get(pair).unsafeRunSync() shouldBe a[Right[_, _]]
+    }
+    
+    // Should make only 1 API call despite 1000 requests
+    mockClient.batchCallCount shouldBe 1
+  }
+  
+  it should "efficiently batch requests for multiple pairs" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.seconds))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.EUR, Currency.JPY),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.USD),
+      Rate.Pair(Currency.CHF, Currency.SGD),
+      Rate.Pair(Currency.AUD, Currency.CAD),
+      Rate.Pair(Currency.NZD, Currency.GBP)
+    )
+    
+    // Initial requests to track pairs
+    pairs.foreach(service.get(_).unsafeRunSync())
+    
+    // Expire cache by advancing time
+    testClock.advance(10.seconds)
+    mockClient.reset()
+    
+    // Request all pairs - should trigger one batch call
+    pairs.foreach(service.get(_).unsafeRunSync())
+    
+    // Should make exactly 1 batch call for all pairs
+    mockClient.batchCallCount shouldBe 1
+  }
+  
+  it should "maintain performance under memory pressure" in {
+    val testClock = new TestClock[IO]
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    // Create many different pairs to test memory usage
+    val currencies = Currency.allCurrencies.toList
+    val pairs = for {
+      from <- currencies
+      to <- currencies
+      if from != to
+    } yield Rate.Pair(from, to)
+    
+    // Request all pairs twice
+    pairs.foreach(service.get(_).unsafeRunSync())
+    pairs.foreach(service.get(_).unsafeRunSync())
+    
+    // First round should make API calls, second round should be cached
+    mockClient.batchCallCount shouldBe pairs.length
+    
+    // Verify cached pairs are managed efficiently
+    cache.getAllCachedPairs.unsafeRunSync().length shouldBe pairs.length
+  }
+  
+  it should "handle rapid cache expiration cycles efficiently" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.seconds))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF)
+    )
+    
+    val cycles = 5
+    var totalApiCalls = 0
+    
+    (1 to cycles).foreach { cycle =>
+      mockClient.reset()
+      
+      // Request all pairs
+      pairs.foreach(service.get(_).unsafeRunSync())
+      
+      if (cycle == 1) {
+        // First cycle: individual calls
+        totalApiCalls += mockClient.callCount
+      } else {
+        // Subsequent cycles: should batch
+        totalApiCalls += mockClient.batchCallCount
+      }
+      
+      // Advance time to expire cache
+      testClock.advance(10.seconds)
+    }
+    
+    // Should use batching efficiently after first cycle
+    totalApiCalls should be <= (pairs.length + cycles - 1)
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/properties/CachedOneFramePropertySpec.scala b/forex-mtl/src/test/scala/forex/properties/CachedOneFramePropertySpec.scala
new file mode 100644
index 00000000..1503363f
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/properties/CachedOneFramePropertySpec.scala
@@ -0,0 +1,179 @@
+package forex.properties
+
+import cats.effect.{ContextShift, IO, Timer}
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import forex.config.CacheConfig
+import forex.domain.{Currency, Rate}
+import forex.helpers.{MockAlgebra, TestClock}
+import forex.services.rates.RateCache
+import forex.services.rates.interpreters.CachedOneFrame
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.concurrent.duration._
+
+class CachedOneFramePropertySpec extends AnyFlatSpec with Matchers {
+  implicit val cs: ContextShift[IO] = IO.contextShift(global)
+  implicit val timer: Timer[IO] = IO.timer(global)
+
+  "CachedOneFrame Properties" should "never make more API calls than distinct pairs requested" in {
+    val testCases = List(
+      List(Rate.Pair(Currency.USD, Currency.EUR)),
+      List(Rate.Pair(Currency.USD, Currency.EUR), Rate.Pair(Currency.JPY, Currency.USD)),
+      List(Rate.Pair(Currency.USD, Currency.EUR), Rate.Pair(Currency.JPY, Currency.USD), Rate.Pair(Currency.GBP, Currency.CHF)),
+      List(Rate.Pair(Currency.USD, Currency.EUR), Rate.Pair(Currency.USD, Currency.EUR)) // duplicate
+    )
+    
+    testCases.foreach { pairs =>
+      val testClock = new TestClock[IO]
+      implicit val clock = testClock
+      
+      val mockClient = new MockAlgebra[IO](Some(testClock))
+      val cache = new RateCache[IO](CacheConfig(5.minutes))
+      val service = new CachedOneFrame[IO](mockClient, cache)
+      
+      // Request all pairs
+      pairs.foreach(service.get(_).unsafeRunSync())
+      
+      // Total API calls should not exceed distinct pairs
+      val totalApiCalls = mockClient.callCount + mockClient.batchCallCount
+      val distinctPairs = pairs.distinct.length
+      
+      totalApiCalls should be <= distinctPairs
+    }
+  }
+  
+  it should "always return successful results for valid pairs when API is working" in {
+    val testPairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF),
+      Rate.Pair(Currency.AUD, Currency.CAD)
+    )
+    
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    // All requests should succeed
+    testPairs.foreach { pair =>
+      val result = service.get(pair).unsafeRunSync()
+      result shouldBe a[Right[_, _]]
+    }
+  }
+  
+  it should "cache all successfully retrieved rates" in {
+    val testPairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF)
+    )
+    
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    // First round: should hit API
+    testPairs.foreach(service.get(_).unsafeRunSync())
+    val initialApiCalls = mockClient.callCount + mockClient.batchCallCount
+    
+    mockClient.reset()
+    
+    // Second round: should use cache
+    testPairs.foreach(service.get(_).unsafeRunSync())
+    val cachedApiCalls = mockClient.callCount + mockClient.batchCallCount
+    
+    cachedApiCalls shouldBe 0
+    initialApiCalls should be > 0
+  }
+  
+  it should "batch efficiently when multiple pairs expire" in {
+    // Use deterministic pairs instead of random generation
+    val testPairs = List(
+      List(Rate.Pair(Currency.USD, Currency.EUR), Rate.Pair(Currency.USD, Currency.JPY)),
+      List(Rate.Pair(Currency.USD, Currency.GBP), Rate.Pair(Currency.USD, Currency.CHF), Rate.Pair(Currency.USD, Currency.SGD)),
+      List(Rate.Pair(Currency.EUR, Currency.JPY), Rate.Pair(Currency.EUR, Currency.GBP), Rate.Pair(Currency.EUR, Currency.CHF), Rate.Pair(Currency.EUR, Currency.AUD))
+    )
+    
+    testPairs.foreach { validPairs =>
+      val testClock = new TestClock[IO]
+      implicit val clock = testClock
+      
+      val mockClient = new MockAlgebra[IO](Some(testClock))
+      val cache = new RateCache[IO](CacheConfig(5.seconds))
+      val service = new CachedOneFrame[IO](mockClient, cache)
+      
+      // Track pairs by requesting them
+      validPairs.foreach(service.get(_).unsafeRunSync())
+      
+      // Advance time to expire cache
+      testClock.advance(10.seconds)
+      mockClient.reset()
+      
+      // Request first pair - should trigger batch for all
+      service.get(validPairs.head).unsafeRunSync()
+      
+      // Should make exactly one batch call
+      mockClient.batchCallCount shouldBe 1
+
+      // Batch should include all expired pairs
+      if (mockClient.batchCalledPairs.nonEmpty) {
+        mockClient.batchCalledPairs.head.toSet shouldBe validPairs.toSet
+      }
+    }
+  }
+  
+  it should "maintain cache consistency under concurrent access" in {
+    val testClock = new TestClock[IO]
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    // Make concurrent requests for the same pair
+    val concurrentRequests = 20
+    val results = (1 to concurrentRequests).map { _ =>
+      service.get(pair).unsafeRunSync()
+    }
+    
+    // All should succeed
+    results.foreach(_ shouldBe a[Right[_, _]])
+    
+    // Should make at most a few API calls despite many concurrent requests
+    val totalApiCalls = mockClient.callCount + mockClient.batchCallCount
+    totalApiCalls should be <= 3 // Allow for some race conditions
+  }
+  
+  it should "track exactly the pairs that were requested" in {
+    val testPairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF),
+      Rate.Pair(Currency.USD, Currency.EUR) // duplicate
+    )
+    
+    val testClock = new TestClock[IO]
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    // Request all pairs
+    testPairs.foreach(service.get(_).unsafeRunSync())
+    
+    // Cached pairs should match distinct requested pairs
+    val cachedPairs = cache.getAllCachedPairs.unsafeRunSync().toSet
+    val distinctRequestedPairs = testPairs.distinct.toSet
+    
+    cachedPairs shouldBe distinctRequestedPairs
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/services/rates/RateCacheSpec.scala b/forex-mtl/src/test/scala/forex/services/rates/RateCacheSpec.scala
new file mode 100644
index 00000000..a9f4ff13
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/services/rates/RateCacheSpec.scala
@@ -0,0 +1,101 @@
+package forex.services.rates
+
+import cats.effect.{ContextShift, IO, Timer}
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import forex.config.CacheConfig
+import forex.domain.{Currency, Rate}
+import forex.helpers.{TestClock, TestData}
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.concurrent.duration._
+
+class RateCacheSpec extends AnyFlatSpec with Matchers {
+  implicit val cs: ContextShift[IO] = IO.contextShift(global)
+  implicit val timer: Timer[IO] = IO.timer(global)
+
+  "RateCache" should "return None for non-existent pairs" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    cache.get(pair).unsafeRunSync() shouldBe None
+  }
+  
+  it should "return cached rate when available and not expired" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val rate = TestData.createTestRate(Currency.USD, Currency.EUR, 1.23)
+    
+    cache.put(rate).unsafeRunSync()
+    
+    val result = cache.get(rate.pair).unsafeRunSync()
+    result shouldBe Some(rate)
+  }
+  
+  it should "return all cached pairs" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val rate1 = TestData.createTestRate(Currency.USD, Currency.EUR)
+    val rate2 = TestData.createTestRate(Currency.JPY, Currency.USD)
+    
+    cache.put(rate1).unsafeRunSync()
+    cache.put(rate2).unsafeRunSync()
+    
+    val cachedPairs = cache.getAllCachedPairs.unsafeRunSync()
+    cachedPairs should contain(rate1.pair)
+    cachedPairs should contain(rate2.pair)
+  }
+  
+  it should "expire rates after TTL" in {
+    val testClock = TestClock[IO]
+    val cache = new RateCache[IO](CacheConfig(2.seconds))(implicitly, testClock)
+    val rate = TestData.createTestRate(Currency.USD, Currency.EUR)
+    
+    cache.put(rate).unsafeRunSync()
+    cache.get(rate.pair).unsafeRunSync() shouldBe Some(rate)
+    
+    testClock.advance(3.seconds)
+    cache.get(rate.pair).unsafeRunSync() shouldBe None
+  }
+  
+  it should "return empty list when no pairs are cached" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    
+    val cachedPairs = cache.getAllCachedPairs.unsafeRunSync()
+    cachedPairs shouldBe List.empty
+  }
+  
+  it should "cache multiple rates in batch" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val rates = List(
+      TestData.createTestRate(Currency.USD, Currency.EUR, 1.1),
+      TestData.createTestRate(Currency.JPY, Currency.USD, 0.007),
+      TestData.createTestRate(Currency.GBP, Currency.EUR, 1.15)
+    )
+    
+    cache.putBatch(rates).unsafeRunSync()
+    
+    rates.foreach { rate =>
+      cache.get(rate.pair).unsafeRunSync() shouldBe Some(rate)
+    }
+  }
+  
+  it should "clear all cached data" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val rate = TestData.createTestRate(Currency.USD, Currency.EUR)
+    
+    cache.put(rate).unsafeRunSync()
+    cache.get(rate.pair).unsafeRunSync() shouldBe Some(rate)
+    
+    cache.clear().unsafeRunSync()
+    cache.get(rate.pair).unsafeRunSync() shouldBe None
+    cache.getAllCachedPairs.unsafeRunSync() shouldBe List.empty
+  }
+  
+  it should "use putBatch for single put operation" in {
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val rate = TestData.createTestRate(Currency.USD, Currency.EUR)
+    
+    cache.put(rate).unsafeRunSync()
+    cache.get(rate.pair).unsafeRunSync() shouldBe Some(rate)
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/services/rates/interpreters/CachedOneFrameSpec.scala b/forex-mtl/src/test/scala/forex/services/rates/interpreters/CachedOneFrameSpec.scala
new file mode 100644
index 00000000..61116143
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/services/rates/interpreters/CachedOneFrameSpec.scala
@@ -0,0 +1,256 @@
+package forex.services.rates.interpreters
+
+import cats.effect.{ContextShift, IO, Timer}
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import forex.config.CacheConfig
+import forex.domain.{Currency, Rate}
+import forex.helpers.{MockAlgebra, TestClock, TestData}
+import forex.services.rates.RateCache
+import forex.services.rates.errors.Error.{InvalidCurrencyPair, OneFrameLookupFailed, RateNotFound}
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import scala.concurrent.duration._
+
+class CachedOneFrameSpec extends AnyFlatSpec with Matchers {
+  implicit val cs: ContextShift[IO] = IO.contextShift(global)
+  implicit val timer: Timer[IO] = IO.timer(global)
+
+  "CachedOneFrame" should "return cached rate when available" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val rate = TestData.createTestRateWithClock(Currency.USD, Currency.EUR, testClock)
+    cache.put(rate).unsafeRunSync()
+    
+    val result = service.get(rate.pair).unsafeRunSync()
+    
+    result shouldBe Right(rate)
+    mockClient.batchCallCount shouldBe 0
+  }
+  
+  it should "make batch request when expired tracked pairs exist" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.seconds))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair1 = Rate.Pair(Currency.USD, Currency.EUR)
+    val pair2 = Rate.Pair(Currency.JPY, Currency.USD)
+    val rate1 = TestData.createTestRateWithClock(pair1.from, pair1.to, testClock)
+    val rate2 = TestData.createTestRateWithClock(pair2.from, pair2.to, testClock)
+    
+    // Track pairs by requesting them
+    cache.get(pair1).unsafeRunSync()
+    cache.get(pair2).unsafeRunSync()
+    
+    // Cache rates
+    cache.put(rate1).unsafeRunSync()
+    cache.put(rate2).unsafeRunSync()
+    
+    // Advance time to expire rates
+    testClock.advance(10.seconds)
+    
+    // Setup mock expectation
+    mockClient.expectBatchCall(List(pair1, pair2))
+    
+    val result = service.get(pair1).unsafeRunSync()
+    
+    result.isRight shouldBe true
+    mockClient.verifyBatchCalled()
+  }
+  
+  it should "make single request when no expired tracked pairs exist" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    val result = service.get(pair).unsafeRunSync()
+    
+    result.isRight shouldBe true
+    mockClient.batchCallCount shouldBe 1
+    mockClient.batchCalledPairs.flatten should contain(pair)
+  }
+  
+  it should "cache rates from batch response" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.seconds))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair1 = Rate.Pair(Currency.USD, Currency.EUR)
+    val pair2 = Rate.Pair(Currency.JPY, Currency.USD)
+    
+    // Track pairs
+    cache.get(pair1).unsafeRunSync()
+    cache.get(pair2).unsafeRunSync()
+    
+    // Create rates and then expire them by advancing time
+    val rate1 = TestData.createTestRateWithClock(pair1.from, pair1.to, testClock)
+    val rate2 = TestData.createTestRateWithClock(pair2.from, pair2.to, testClock)
+    cache.put(rate1).unsafeRunSync()
+    cache.put(rate2).unsafeRunSync()
+    
+    // Advance time to expire rates (TTL is 5.seconds)
+    testClock.advance(10.seconds)
+    
+    val result = service.get(pair1).unsafeRunSync()
+    
+    result.isRight shouldBe true
+    
+    // Both rates should now be cached from the batch response
+    cache.get(pair1).unsafeRunSync().isDefined shouldBe true
+    cache.get(pair2).unsafeRunSync().isDefined shouldBe true
+  }
+  
+  it should "handle batch API failures gracefully" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.seconds))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    // Track and expire pair
+    cache.get(pair).unsafeRunSync()
+    
+    // Create rate and expire it by advancing time
+    val rate = TestData.createTestRateWithClock(pair.from, pair.to, testClock)
+    cache.put(rate).unsafeRunSync()
+    
+    // Advance time to expire rate (TTL is 5.seconds)
+    testClock.advance(10.seconds)
+    
+    mockClient.setBatchShouldFail(true)
+    
+    val result = service.get(pair).unsafeRunSync()
+    
+    result.isLeft shouldBe true
+    result.left.getOrElse(fail()) shouldBe a[OneFrameLookupFailed]
+  }
+  
+  it should "handle single API failures gracefully" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    mockClient.setBatchShouldFail(true)
+    
+    val result = service.get(pair).unsafeRunSync()
+    
+    result.isLeft shouldBe true
+    result.left.getOrElse(fail()) shouldBe a[OneFrameLookupFailed]
+  }
+  
+  it should "return error when requested pair not found in batch response" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock)) {
+      override def getBatch(pairs: List[Rate.Pair])(implicit F: cats.Applicative[IO]) = {
+        // Return empty list instead of expected rates
+        IO.pure(Right(List.empty[Rate]))
+      }
+    }
+    val cache = new RateCache[IO](CacheConfig(5.seconds))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    // Track and expire pair
+    cache.get(pair).unsafeRunSync()
+    
+    // Create rate and expire it by advancing time
+    val rate = TestData.createTestRateWithClock(pair.from, pair.to, testClock)
+    cache.put(rate).unsafeRunSync()
+    
+    // Advance time to expire rate (TTL is 5.seconds)
+    testClock.advance(10.seconds)
+    
+    val result = service.get(pair).unsafeRunSync()
+    
+    result.isLeft shouldBe true
+    result.left.getOrElse(fail()) shouldBe RateNotFound("USDEUR")
+  }
+  
+  it should "cache single API response" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    val result = service.get(pair).unsafeRunSync()
+    
+    result.isRight shouldBe true
+    
+    // Rate should now be cached
+    val cachedResult = service.get(pair).unsafeRunSync()
+    cachedResult.isRight shouldBe true
+    
+    // Should have made only one API call
+    mockClient.batchCallCount shouldBe 1
+  }
+  
+  it should "reject same currency pairs early" in {
+    val testClock = new TestClock[IO]
+    implicit val clock = testClock
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    val samePair = Rate.Pair(Currency.USD, Currency.USD)
+    
+    val result = service.get(samePair).unsafeRunSync()
+    
+    result.isLeft shouldBe true
+    result.left.getOrElse(fail()) shouldBe InvalidCurrencyPair("USDUSD", "same currency conversion not supported")
+    
+    // Should not call API or access cache for invalid pairs
+    mockClient.batchCallCount shouldBe 0
+    mockClient.callCount shouldBe 0
+  }
+  
+  it should "not add invalid pairs to tracked pairs" in {
+    val testClock = new TestClock[IO]
+    
+    val mockClient = new MockAlgebra[IO](Some(testClock))
+    val cache = new RateCache[IO](CacheConfig(5.minutes))
+    val service = new CachedOneFrame[IO](mockClient, cache)
+    
+    // Try to get invalid pair
+    service.get(Rate.Pair(Currency.EUR, Currency.EUR)).unsafeRunSync()
+    
+    // Should not be cached
+    val cachedPairs = cache.getAllCachedPairs.unsafeRunSync()
+    cachedPairs should not contain Rate.Pair(Currency.EUR, Currency.EUR)
+    
+    // Should not make API calls
+    mockClient.batchCallCount shouldBe 0
+  }
+}
\ No newline at end of file
diff --git a/forex-mtl/src/test/scala/forex/services/rates/interpreters/OneFrameClientSpec.scala b/forex-mtl/src/test/scala/forex/services/rates/interpreters/OneFrameClientSpec.scala
new file mode 100644
index 00000000..6dfa7578
--- /dev/null
+++ b/forex-mtl/src/test/scala/forex/services/rates/interpreters/OneFrameClientSpec.scala
@@ -0,0 +1,153 @@
+package forex.services.rates.interpreters
+
+import cats.effect.{ContextShift, IO, Timer}
+
+import scala.concurrent.ExecutionContext.Implicits.global
+import forex.config.OneFrameConfig
+import forex.domain.{Currency, Rate}
+import forex.services.rates.errors.Error._
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import scala.concurrent.duration._
+
+class OneFrameClientSpec extends AnyFlatSpec with Matchers {
+  implicit val cs: ContextShift[IO] = IO.contextShift(global)
+  implicit val timer: Timer[IO] = IO.timer(global)
+
+  "OneFrameClient" should "build correct URL for single pair" in {
+    val config = OneFrameConfig("http://api.example.com/rates?", "test-token", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+
+    val url = client.buildBatchUrl(List(pair))
+    url shouldBe "http://api.example.com/rates?pair=USDEUR"
+  }
+  
+  it should "build correct URL for multiple pairs" in {
+    val config = OneFrameConfig("http://api.example.com/rates?", "secret-key", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    val pairs = List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.USD),
+      Rate.Pair(Currency.GBP, Currency.CHF)
+    )
+    
+    val url = client.buildBatchUrl(pairs)
+    url shouldBe "http://api.example.com/rates?pair=USDEUR&pair=JPYUSD&pair=GBPCHF"
+  }
+  
+  it should "handle special characters in base URL" in {
+    val config = OneFrameConfig("http://api.example.com:8080/api/v1/rates?", "token123", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    val pairs = List(Rate.Pair(Currency.CHF, Currency.SGD))
+    
+    val url = client.buildBatchUrl(pairs)
+    url shouldBe "http://api.example.com:8080/api/v1/rates?pair=CHFSGD"
+  }
+  
+  it should "build URL for empty pair list" in {
+    val config = OneFrameConfig("http://test.com/rates?", "test-token", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    
+    val url = client.buildBatchUrl(List.empty)
+    url shouldBe "http://test.com/rates?"
+  }
+  
+  it should "handle empty batch request" in {
+    val config = OneFrameConfig("http://test.com/rates?", "test-token", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    
+    val result = client.getBatch(List.empty).unsafeRunSync()
+    
+    result shouldBe Right(List.empty)
+  }
+
+  // Error handling tests - using malformed URLs to test error handling logic
+  it should "handle invalid URL configuration" in {
+    // Use invalid protocol to trigger connection error
+    val config = OneFrameConfig("invalid-protocol://test.com/rates?", "test-token", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    val pairs = List(Rate.Pair(Currency.USD, Currency.EUR))
+    
+    val result = client.getBatch(pairs).unsafeRunSync()
+    
+    result.isLeft shouldBe true
+    result.left.foreach { error =>
+      error shouldBe a[NetworkError]
+      error.message should not be empty
+    }
+  }
+
+  it should "properly map single pair failures to get() method" in {
+    // Test that single pair method correctly handles batch failures
+    val config = OneFrameConfig("invalid://bad-url", "test-token", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    val pair = Rate.Pair(Currency.USD, Currency.EUR)
+    
+    val result = client.get(pair).unsafeRunSync()
+    
+    result.isLeft shouldBe true
+    result.left.foreach { error =>
+      error shouldBe a[NetworkError]
+    }
+  }
+  
+  it should "handle empty batch response correctly in get() method" in {
+    // This would require mocking, but we can test the URL building at least
+    val config = OneFrameConfig("http://test.com/rates?", "test-token", 30.seconds) 
+    val client = new OneFrameClient[IO](config)
+    
+    // Test URL generation works correctly for edge cases
+    val singlePairUrl = client.buildBatchUrl(List(Rate.Pair(Currency.USD, Currency.USD)))
+    singlePairUrl should include("USDUSD")
+  }
+
+  // Test error message patterns from actual OneFrameClient error handling
+  it should "create appropriate error messages for different failure scenarios" in {
+    val config = OneFrameConfig("http://test.com/rates?", "test-token", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    
+    // Test URL building works for various scenarios
+    val multiPairUrl = client.buildBatchUrl(List(
+      Rate.Pair(Currency.USD, Currency.EUR),
+      Rate.Pair(Currency.JPY, Currency.GBP),
+      Rate.Pair(Currency.CHF, Currency.AUD)
+    ))
+    
+    multiPairUrl should include("pair=USDEUR")
+    multiPairUrl should include("pair=JPYGBP") 
+    multiPairUrl should include("pair=CHFAUD")
+    multiPairUrl should include("&") // Should have proper URL param separators
+  }
+
+  it should "handle edge case currency combinations in URL building" in {
+    val config = OneFrameConfig("https://api.example.com:8443/v2/rates?", "secret123", 30.seconds)
+    val client = new OneFrameClient[IO](config)
+    
+    // Test various currency combinations
+    val pairs = List(
+      Rate.Pair(Currency.SGD, Currency.NZD),
+      Rate.Pair(Currency.CAD, Currency.AUD)
+    )
+    
+    val url = client.buildBatchUrl(pairs)
+    url shouldBe "https://api.example.com:8443/v2/rates?pair=SGDNZD&pair=CADAUD"
+  }
+  
+  it should "handle time synchronization checks without throwing exceptions" in {
+    val config = OneFrameConfig("http://test.com/rates?", "test-token", 10.seconds)
+    val client = new OneFrameClient[IO](config)
+    
+    // Test various timestamp scenarios - should not throw exceptions
+    val validTimestamp = java.time.OffsetDateTime.now().toString
+    val futureTimestamp = java.time.OffsetDateTime.now().plusMinutes(1).toString  
+    val pastTimestamp = java.time.OffsetDateTime.now().minusMinutes(1).toString
+    val invalidTimestamp = "not-a-timestamp"
+    
+    // These should execute without throwing exceptions
+    noException should be thrownBy client.checkTimeSync(validTimestamp)
+    noException should be thrownBy client.checkTimeSync(futureTimestamp)
+    noException should be thrownBy client.checkTimeSync(pastTimestamp) 
+    noException should be thrownBy client.checkTimeSync(invalidTimestamp)
+  }
+}
\ No newline at end of file