Ultra-Low-Latency Call Metadata API using Go lang

@Shonali1406

Hello, I understand you need an ultra-low latency, stateless Go microservice that ingests real-time telecom events, persists them in Redis, and exposes near-instant query access for downstream AI systems. With 12+ years in Go, microservices, Redis, and GCP, my approach is to design a highly concurrent, memory-efficient service using idiomatic Go patterns and optimized Redis access to consistently achieve sub-10ms P95 latency. Proposed Approach: • Non-blocking HTTP handlers with connection pooling • Redis key design with TTL + optional Streams for extensibility • Optimized JSON ingestion and indexed lookup paths • Stateless container tuned for fast Cloud Run cold starts Deliverables & Skills: • Production-ready Go service + modular structure • Redis schema (keys, TTL, scaling strategy) • Dockerfile + Cloud Run deployment manifest • README + cURL examples • Latency benchmark script (<10ms P95) Why hire me: I build high-performance, scalable systems with proven low-latency results. Let’s collaborate and deliver a real-time system that performs under pressure.

@goranm16

Hi, this fits very closely with the kind of backend work I do. I can build the Go service as a small stateless Cloud Run API with clean JSON ingest, Redis-backed lookup, tight connection pooling, TTL-based call keys, and a simple latency test so you can verify the P95 target on your GCP setup. I’ve built similar event-driven API layers where incoming records had to be stored, indexed, and fetched immediately by downstream automation without keeping state in the app nodes. I’d start by locking the Redis key model and endpoint contract, then build the ingest/lookup path with benchmarks before adding Docker, Cloud Run config, and README examples. The main risk is latency drift from Redis/network setup rather than Go itself, so I’d keep the Redis access pattern minimal, reuse connections properly, and test inside the same region from the start. Thanks!

@Hrolgar

Sub-10ms P95 on Cloud Run is the constraint to design around because cold starts will destroy it if you're not careful. My plan: min-instances=1 on the Cloud Run service, connection pool pre-warmed to Redis at container init (not per-request), and the Redis client tuned for pipelining on both ingest and read paths. For the ingest side, I'd use Redis Streams rather than plain keys for the call events. XADD at ~1ms, TTL via MAXLEN, and downstream AI agents can consume via consumer groups without conflicting with the lookup API. Keys for the lookup endpoint get derived from stream entries so there's one write, two access patterns. Milestones (INR 32,000 total, 2 weeks): M1 Go module + Redis schema (stream + lookup keys) + ingest endpoint, 10k, 4d M2 Lookup endpoint + concurrency tuning + benchmarks proving <10ms P95, 12k, 5d M3 Dockerfile + Cloud Run manifest + README + latency test script, 10k, 5d Stateless design is straightforward. No local caches, no leader election, just the Redis connection. I'll document scaling behavior (min/max instances, autoscale triggers) so you can tune later. One question: what's the expected peak events/sec from Orange's feed? And is Redis in the same GCP region as Cloud Run? Cross-region Redis adds 20 to 40ms alone.

@himanshus642

Hi, This is a strong real-time system use-case. I can build a stateless Go microservice with Redis-backed storage optimized for sub-10ms P95 latency on Cloud Run. Experience: * Built Go services with Redis for low-latency pipelines * Designed stateless APIs for containerized environments (Cloud Run/VPS) * Handled high-concurrency ingestion and fast lookup systems Approach: * Lightweight Go service (net/http or Fiber) with optimized connection pooling * Redis schema using hashed keys + TTL for fast reads and memory control * Optional use of Redis streams if ordering or replay is needed * Non-blocking ingest endpoint → immediate write to Redis * Lookup endpoint tuned for sub-ms reads (same-region Redis) Infra: * Dockerized build (fast startup, minimal image size) * Cloud Run deployment config (CPU/memory optimized) * Efficient connection reuse for Redis Deliverables: * Clean Go codebase (modular) * Redis schema + TTL strategy * Dockerfile + Cloud Run manifest * README with curl examples * Latency test script Timeline: 5–7 days Quick question: Will Redis be managed (MemoryStore) or self-hosted? I can deliver a production-ready, low-latency system aligned with your constraints.

@alluankit01

Hi, This is a strong fit because the requirement is very clear: **stateless Go service, Redis-backed, ultra-low-latency lookup, Cloud Run deployment, and clean production structure**. I can help build this the right way so ingest and lookup stay fast, predictable, and easy to operate. My approach would be: * design a minimal Go service with **tight Redis key/TTL strategy** * optimize connection pooling and concurrent request handling * keep the service fully stateless for Cloud Run scaling/recycling * provide **ingest + lookup** endpoints with clean JSON handling * deliver Dockerfile, deployment manifest, README, and a latency test script What matters most here is not just “working code,” but making sure the service consistently meets the latency target in real deployment conditions. I’d focus first on the Redis access pattern and API path so downstream systems can fetch call metadata in the shortest possible path. I’m comfortable with **Go, Redis, Docker, microservices, and low-latency API design**, and I can keep the code modular enough for future format expansion later. If you send me the expected event shape and lookup pattern, I can tell you the cleanest implementation path right away. Best regards. Ankit.

@bbhanvadia

Hi, I came across your project and it’s a great match for my automation expertise. With 5+ years of experience, I specialize in building smart automation workflows using tools like n8n, helping businesses save time and improve efficiency. I have built automation systems for lead management, CRM integration, API workflows, email automation, and AI-based processes. My goal is to reduce manual work and create seamless, scalable systems. For your project, I can design a custom n8n workflow that connects your tools, automates repetitive tasks, and ensures smooth data flow across platforms. I focus on reliability, clean structure, and easy scalability. Whether it’s integrating APIs, automating business processes, or creating AI-powered workflows, I can deliver a complete solution tailored to your needs. Quick question: Which tools or platforms do you want to integrate in this automation? I’m ready to start immediately. Best regards, Bhargav

@ttobio69

Hi there, I read your requirements carefully, and I can build a stateless Go microservice for ultra-fast call metadata ingest and lookup using Redis, JSON APIs, Docker, and Google Cloud Run. I’ll design clean ingest/lookup endpoints, an efficient Redis key + TTL strategy, tight Go concurrency/connection handling, and deployment-ready Docker/Cloud Run config. I’ll also include README commands and a latency test script to demonstrate P95 lookup performance under your target. Cost: ₹23,000 || Timeline: 2 days Payment and timeline details can be discussed further to align with your expectations. I’d be happy to build this as a clean, production-ready low-latency microservice. Best regards, Oluwatobi Okedairo

@bunnyb36

With my extensive experience in software development particularly within backend and full stack projects, I am confident that I can successfully build the Ultra-Low-Latency Call Metadata API using Go Lang that you require. During my tenure at a Gen AI startup in Hyderabad, I effectively handled projects with significant scalability and latency demands. These very qualities are required for your project. One of my specialties is building stateless, highly performant micro-services which is exactly what you've specified. I have a robust understanding of Go's idiomatic concurrency and connection handling, allowing me to deliver a high-performing and well-optimized codebase tailored to your specific needs. Additionally, I am more than comfortable in working with shared in-memory databases such as Redis, and can ensure speedy data access and an efficient Redis schema design which can handle high load and adapt well for future formats. Given the specifications and goals of the project, it's clear that end-to-end latency under the network round-trip is crucial and something I prioritize greatly. My technical skills coupled with meticulous attention to detail guarantee that your service will meet sub-millisecond read times with ease, as outlined in the project description. Above all, I am resilient and committed to delivering nothing less than excellence which makes me an ideal candidate for this essential call metadata API task.

@techotd

Hi, This is a well-defined, performance-critical use case and I can help you build a low-latency, stateless Go microservice optimized for real-time telecom events. My Approach: • Build a lightweight Go service (net/http or Fiber) with clean modular structure • Use Redis (go-redis) with optimized key design + TTL strategy for fast reads • Store events using hash/JSON or Redis Streams (depending on query pattern) • Ensure sub-ms read latency via connection pooling, pipelining & minimal serialization API Design: • /ingest → accepts JSON event, validates & pushes to Redis • /lookup → fetch by call/session ID with ultra-fast response Performance Focus: • Stateless design (Cloud Run friendly) • Efficient goroutine handling & connection reuse • Benchmarking + latency script to validate <10ms P95 • Memory-conscious Redis schema Deliverables: ✔ Production-ready Go code (clean, scalable) ✔ Redis schema + TTL & design rationale ✔ Dockerfile + Cloud Run deployment config ✔ README with curl examples ✔ Latency test script + demo setup I’ve built similar high-throughput, low-latency services and understand how to optimize Go + Redis for real-time systems. Ready to start immediately and deliver a fast, reliable service that meets your latency targets. Best Regards, Arun

@Sadiyasyeda24

Hello, I understand the task and will ensure your expectations are me. I am a skilled freelancer with 4 years of experience in Software Development, Automation, API Development. Visit my profile to view latest projects. Please connect in chat so we can discuss. Warm regards, Syeda Tahreem

@aurvixlabs

Your stateless Go service needs to ingest Orange's push feed into Redis and expose sub-millisecond lookup — the trick is structuring Redis keys for shard-free TTL expirations and tight connection reuse. In PolyGNN, I built a hybrid GNN API on FastAPI with Redis caching that hit <2ms p99 reads under load. I bring idiomatic Go concurrency, Redis pipeline design, and Cloud Run stateless deployment from my AWS ML certification and Docker/GCP work. I'd deliver in two milestones: first the Go module with Redis schema and endpoints, then Dockerized Cloud Run deployment with a latency test. Quick question — are you using Redis Streams for the feed ordering or a simple SET/GET with TTL for event expiry?

@shubham5175

Hi, I’m a strong fit for this project because I build high-performance backend systems in Go with a focus on low-latency APIs, distributed services, and production-ready cloud deployments. I reviewed your spec and understand the required design: a stateless Go service on Cloud Run that ingests JSON call events, writes them into Redis using a hash + sorted-set schema with TTL, and exposes near-instant lookup APIs by ANI and UUID. I can implement this with idiomatic Go, Redis connection pooling, pipelined writes, HTTP keep-alive, and a deployment setup optimized for Cloud Run. I can deliver: * Production-ready Go microservice * Redis schema and TTL strategy * Dockerfile and Cloud Run manifest * README with sample cURL commands * Latency test script for same-region validation My focus will be to keep the service simple, fast, and reliable enough to demonstrate sub-10 ms P95 downstream fetch performance in your GCP environment. Best regards, Shubham Joshi

@brysonp3

Hi , Good afternoon! I am professional mobile programmer with skills including Microservices, Cloud Computing, Golang, JSON, Software Engineering, Redis, Software Development, Docker, API Development and Automation. I am checking your attachment, I'll update you shortly... Please contact me to discuss more about this project. Thanks & Regards

@find1234

Hi! I can build your stateless ultra-low-latency Go API for call metadata. **My Experience:** ✅ Go microservices (5+ years) ✅ Redis cluster + in-memory storage optimization ✅ Google Cloud Run deployment ✅ High-performance APIs (<1ms latency) ✅ Idiomatic Go concurrency patterns **My Approach:** 1. **Redis Schema:** Design key structure with TTL strategy for auto-cleanup 2. **Go Service:** Stateless HTTP handlers with connection pooling 3. **Performance:** Sub-millisecond Redis lookups via pipelining 4. **Cloud Run:** Optimized Docker image for fast cold starts 5. **Testing:** Latency benchmark script with P95 metrics **Deliverables:** - Production Go code with clear modules - Redis key schema documentation - Dockerfile + Cloud Run manifest - README with deployment guide - Latency test script (<10ms P95 guaranteed) **At ₹16,500**, I offer the **best value** - 30% below average! Ready to achieve sub-10ms latency! ?

@adi6125

Hi, I went through your PRD—it’s a solid design, especially the dual-write Redis pattern and focus on single round-trip operations. I wouldn’t change the architecture; I’d focus on executing it cleanly and ensuring latency targets are consistently met. I’ll pipeline the ingest flow (HSET + ZADD + EXPIRE) over pre-warmed Redis connections to avoid extra RTT. The Go service will stay lean (no heavy frameworks), with efficient handlers, proper connection pooling, and HTTP keep-alive. All lookups (ANI/UUID) will be kept to a single Redis round-trip. A couple of points I’ll handle carefully: * Avoid edge cases where TTL on index/payload can drift under high churn * Keep sorted sets bounded if ANI traffic spikes * Add lightweight validation/rate limiting since v1 is public I’ve built similar real-time systems, and sub-10ms P95 in-region is very achievable with this setup. Timeline: **2–3 days** Day 1: Core service + Redis integration Day 2: Remaining APIs, Docker, Cloud Run Day 3: Latency testing + tuning (if needed) You’ll get clean Go code, Redis schema, deployment config, and a latency test script. I can start immediately and have a working version ready in ~48 hours. Thanks, Aditya