Case Study: Fintech Startup Delivers Real-Time Currency Conversion at Scale

Core conversion logic deployed on origin servers with Redis caching layer to minimize API calls and maximize speed.

// Node.js implementation with Redis caching
const redis = require(''redis'');
const axios = require(''axios'');

const CACHE_TTL = 300; // 5 minutes

async function convertCurrency(from, to, amount) '{'
  const cacheKey = `rate:$'{'from'}':$'{'to'}'`;

  // Check Redis cache first
  const cachedRate = await redis.get(cacheKey);
  if (cachedRate) '{'
    const rate = parseFloat(cachedRate);
    return '{'
      from, to, amount,
      converted: (amount * rate).toFixed(2),
      rate, cached: true
    '}';
  '}'

  // Cache miss: fetch from AppHighway
  const response = await axios.get(
    ''https://apphighway.com/api/v1/currency-converter'',
    '{'  params: '{'  from, to, amount: 1  '}',
       headers: '{'  Authorization: `Bearer $'{'API_KEY'}'` '}',
       timeout: 2000
    '}'
  );
  const rate = response.data.rate;

  // Store in Redis with 5-minute TTL
  await redis.setex(cacheKey, CACHE_TTL, rate.toString());

  return '{'  from, to, amount,
    converted: (amount * rate).toFixed(2),
    rate, cached: false
  '}';
'}'

module.exports = '{'  convertCurrency  '}';

CloudFlare Workers deployed globally to serve currency conversions from the nearest edge location, reducing network latency by 60%.

// CloudFlare Worker: Edge currency conversion
export default '{'
  async fetch(request, env) '{'
    const url = new URL(request.url);
    const from = url.searchParams.get(''from'');
    const to = url.searchParams.get(''to'');
    const amount = parseFloat(
      url.searchParams.get(''amount'')
    );

    const cacheKey = `rate_$'{'from'}'_$'{'to'}'`;

    // Check CloudFlare KV cache
    const cachedRate = await env.CURRENCY_RATES.get(cacheKey);
    if (cachedRate) '{'
      const rate = parseFloat(cachedRate);
      return new Response(JSON.stringify('{'
        from, to, amount,
        converted: (amount * rate).toFixed(2),
        rate, source: ''edge_cache''
      '}')); 
    '}'

    // Cache miss: forward to origin
    const originResponse = await fetch(originUrl);
    const data = await originResponse.json();

    // Store rate in edge KV
    await env.CURRENCY_RATES.put(
      cacheKey, data.rate.toString(),
      '{'  expirationTtl: 300  '}'
    );

    return new Response(JSON.stringify(data));
  '}'
'}';

Admin dashboard displays real-time rates for 50+ currency pairs. Batch endpoint converts all pairs in a single API call instead of 50 sequential calls.

// Batch currency conversion endpoint
router.post(''/convert/batch'', async (req, res) => '{'
  const '{'  base_currency, target_currencies, amount  '}' = req.body;

  // Step 1: Check Redis cache for all pairs
  const pipeline = redis.pipeline();
  target_currencies.forEach(target => '{'
    pipeline.get(`rate:$'{'base_currency'}':$'{'target'}'`);
  '}');
  const cachedRates = await pipeline.exec();

  // Step 2: Identify hits and misses
  const cacheHits = [];
  const cacheMisses = [];
  target_currencies.forEach((target, index) => '{'
    const cached = cachedRates[index][1];
    if (cached) cacheHits.push('{'  to: target, rate: parseFloat(cached)  '}');
    else cacheMisses.push(target);
  '}');

  // Step 3: Fetch missing from AppHighway
  if (cacheMisses.length > 0) '{'
    const response = await axios.post(apiUrl, '{'
      from: base_currency,
      to: cacheMisses, amount: 1
    '}');
    // Store and collect results
  '}'

  res.json('{'  base_currency, amount, conversions: results  '}');
'}');

Intelligent rate limiting prevents API overuse while maintaining performance during traffic spikes.

// Rate limit optimization with sliding window
const rateLimit = require(''express-rate-limit'');
const RedisStore = require(''rate-limit-redis'');

// Tier-based rate limiting
const rateLimiters = '{'
  // Public API: 100 requests per minute per IP
  public: rateLimit('{'
    store: new RedisStore('{'  client: redis  '}'),
    windowMs: 60 * 1000,
    max: 100,
    message: ''Too many requests''
  '}'),

  // Authenticated: 500 requests per minute
  authenticated: rateLimit('{'
    store: new RedisStore('{'  client: redis  '}'),
    windowMs: 60 * 1000,
    max: 500,
    keyGenerator: (req) => req.user.id
  '}'),

  // Internal services: no rate limit
  internal: (req, res, next) => next()
'}';

// Apply based on authentication
app.use(''/api/convert'', (req, res, next) => '{'
  if (req.user) return rateLimiters.authenticated(req, res, next);
  return rateLimiters.public(req, res, next);
'}');

95% cache hit rate means only 5% of requests hit AppHighway API. At 250k conversions/day, caching reduces monthly costs from $3,750 to $188, a 95% reduction.

Edge cache hits: 8ms average. Origin cache hits: 28ms average. Origin cache misses: 63ms average. Weighted average: 11.3ms. Without edge: 31ms (3x slower).

Legacy provider: $0.01 per transaction. AppHighway + infrastructure: $0.00016 per transaction. Per-transaction costs reduced 98.4%.