High-Concurrency API Testing Platform
$1500-3000 USD
Posted 1 minute ago
•
Ends in 6 days
$1500-3000 USD
Paid on delivery
We are building an internal distributed API testing and load-simulation framework in Python/Go to benchmark and validate our proprietary client-server communication protocols under high concurrency. Core Scope of Work: Custom Protocol Client: Implement a clean, high-performance HTTP/2 and TCP/TLS client module capable of handling custom cryptographic payload signing (AES/RSA/HMAC) and session token lifecycles. Distributed Execution Engine: Architect a multi-worker task scheduler using asyncio/goroutines and Redis to manage concurrent connections, state persistence, and graceful error/retry handling. Network Routing & Telemetry: Support configurable outbound network interfaces/gateways, connection pooling, latency tracking, and centralized logging/metrics reporting. Requirements: Strong proficiency in Python (Asyncio) or Go (Golang). Deep understanding of network protocols (HTTP/2, TLS handshakes, WebSockets) and applied cryptography. Experience building high-throughput distributed systems and Linux server deployment. Please share your relevant backend and network programming experience in your proposal.
Project ID: 40817737
About the project
30 proposals
Open for bidding
Remote project
Active 4 secs ago
Place your bid
Bid amount Email addressBenefits of bidding on Freelancer
Set your budget and timeframe
It's free to sign up and bid on jobs
30 freelancers are bidding on average $2,060 USD for this job


Our 18+ years of software development experience and strong Python/API development background make CnELIndia well suited to building an internal API testing platform that is reliable, maintainable, and scalable. We specialize in software architecture and backend development, with Django and Python expertise directly relevant to your protocol client and distributed test framework. I can contribute to designing clean API services, structured task orchestration, session and state handling, error management, and telemetry-oriented backend components. Our experience across 743+ client projects reflects disciplined engineering and delivery of production-focused web and application solutions, while the architecture focus supports a modular foundation for high-concurrency testing and future protocol expansion. I would be glad to apply my Python, API development, and software architecture skills to your high-throughput testing initiative and deliver a robust framework aligned with your internal benchmarking needs.


Hi, I understand you need an internal Python/Go platform for high-concurrency testing of proprietary client-server protocols. I can design the Software Architecture around an async worker model, then build the Python API components for HTTP/2 and TCP/TLS communication, AES/RSA/HMAC signing, token handling, retries, and connection pooling. Redis can manage task state and worker coordination, while telemetry will capture latency, failures, throughput, and centralized logs. I will also cover configurable network routing and Linux deployment, with clear tests for concurrency and protocol behavior. My backend and network programming experience includes Python asyncio, API Development, distributed workers, secure request flows, and performance-focused service design. Can you share the protocol specification and expected peak concurrent connections so I can size the worker, Redis, and connection-pooling design correctly? Please start the chat and let’s discuss the protocol details, test targets, and delivery plan.


Your framework needs to produce trustworthy benchmarks, not just a high number of concurrent connections. If the load generator saturates its own CPU or network interface first, the results will misrepresent your protocol’s performance. I’d build a protocol client with clearly separated signing, transport, and session handling so AES/RSA/HMAC behavior can be validated independently. For distributed runs, I’d use Redis to coordinate workers and preserve run state, with bounded concurrency, controlled retries, and graceful shutdown. I’d also track connection and handshake failures separately from application errors, and report latency percentiles alongside worker resource usage. My relevant backend and network experience includes asynchronous clients, Redis-coordinated workloads, TLS/HTTP communication, and Linux deployment. I’d start by reviewing your protocol specification and a representative request flow, then agree on the benchmark scenarios and success criteria before implementation. Can you share those specifications and your target concurrency?


Hi, I've spent the last decade building distributed systems and high-throughput backends—including custom protocol clients, async task schedulers, and production load-testing frameworks—so I understand the architectural challenges you're facing here. I'll start by implementing the custom protocol client in Python with asyncio, handling HTTP/2, TLS, and your cryptographic payload signing (AES/RSA/HMAC) with proper session token lifecycle management. Next, I'll build the distributed execution engine using asyncio workers coordinated through Redis, managing concurrent connections, state persistence, and retry logic. For telemetry, I'll add configurable network interface routing, connection pooling, latency tracking, and centralized metrics collection so you can see exactly what's happening under load. The main production consideration is ensuring connection state doesn't leak across test runs and that backpressure is handled correctly when workers saturate—I'll test this against real protocol data before handoff to catch timing issues early. I'm available now and will stay on for any adjustments or questions once you're running tests.


Hi there, Thank you for sharing your vision for a high-concurrency API testing platform. I am excited about the opportunity to contribute, as your requirements closely align with my expertise in building distributed backend systems with advanced networking and cryptography. With over 8 years of hands-on experience in Python (asyncio, FastAPI, Django) and Go, I have engineered scalable, high-performance client-server architectures for fintech and SaaS products. My recent projects include developing custom HTTP/2 and TCP/TLS clients, implementing AES/RSA/HMAC signing, and architecting distributed load-testing frameworks using Redis for state management and task scheduling. I understand your need for a robust execution engine, so I propose leveraging Python asyncio with a modular worker system. This will enable efficient concurrency, precise connection pooling, and resilient error handling. For network routing, I have configured multi-interface outbound traffic and built telemetry modules that provide real-time metrics and centralized logging over Prometheus or ELK stacks. Security is a core focus: I follow best practices for session token handling, secure key management, and cryptographic payload validation. I deploy and optimize these systems on Linux, ensuring reliability and low-latency performance at scale. I look forward to discussing how I can help you achieve comprehensive, high-throughput protocol validation with actionable insights. Best Regards


I would love to work with you on developing your web app. You're building a distributed API testing platform to validate your proprietary protocols under high concurrency. Your core challenge is implementing HTTP/2 clients with custom AES/RSA signing and coordinating them through Redis. Here is how you get it: I start by reviewing your current setup and confirming the exact flow with you. Then the screens in Figma, a short call while you review them, and the build after your approval in your stack, with clean code, a backup before any change, and testing on a staging copy before anything goes live. You get the full code, a short guide, and everything working on desktop and mobile. 17+ years and 4,100+ projects completed. Please message me here so we can discuss your project further. Waiting for your kind response. Cheers! Salma N.


⚠️ If you're not happy, you don’t pay. ⚠️ Hi Client, Thank you for checking my proposal and sharing the detailed project brief. I can build your internal distributed API testing and load-simulation framework using Python with a high-performance and scalable design. I will deliver: • A custom Protocol Client for HTTP/2 and TCP/TLS with AES/RSA/HMAC cryptographic payload signing. • A Distributed Execution Engine leveraging asyncio for efficient multi-worker task scheduling and Redis for state management. • Configurable network routing with connection pooling and robust latency tracking. • Centralized logging and metrics reporting for real-time performance insights. You will also receive comprehensive documentation and ongoing support for seamless integration. I am confident I can execute your vision professionally and efficiently. Looking forward to discussing timeline and next steps. Best regards, Chirag Pipal.


hello handling thousands of TLS handshakes concurrently while applying per-request cryptographic payload signing will bottleneck the CPU before the network if the crypto operations block the event loop, so this requires offloading signing to a thread pool or implementing it entirely in Go with pipelined connections. i have built high-throughput distributed load testing frameworks in Go using goroutines, custom connection pools, and non-blocking AES/HMAC pipelines. have you benchmarked your expected throughput per worker node, and is state persistence handled via Redis streams or basic pub/sub? have a nice day


Distributed load testing is where race conditions hide, especially around result aggregation when you scale workers past a few hundred concurrent nodes. I would build the coordinator in Go for the worker fleet, Python for scripting test scenarios, and Django for the dashboard and reporting layer. Can start today, working prototype of the worker coordination piece in 4 days. These numbers come from the post as written, we will firm them up once we cover the full scope. Want to jump on a quick call?


Hello, Your platform’s key challenge is coordinating high-concurrency HTTP/2 and TCP/TLS sessions while preserving protocol signing, token lifecycles, retries, and useful telemetry across workers. I would first establish a focused working milestone: a Python asyncio or Go client core, Redis-backed task coordination, connection pooling, and representative load execution with latency and failure metrics. My background includes Python, Node.js backend systems, API integrations, automation platforms, and distributed workflow design. I would keep cryptographic signing isolated behind testable interfaces so AES, RSA, and HMAC behavior can be validated independently, then deploy and benchmark the workers on Linux. Within seven days, I can deliver the initial executable milestone with documented setup, test scenarios, and performance observations, providing a solid base for protocol expansion. Best regards, Bohdan


Python API development and Linux-based software architecture are the strongest match for your distributed API testing platform. I specialize in building custom software and scalable backend systems, with skills in Python, Django, API Development, Linux, and Software Architecture—directly relevant to a high-concurrency framework and its internal services. My backend experience includes REST API development, SaaS platforms, business automation, admin systems, and secure, maintainable application architecture. I can contribute to the Python side of your protocol client and distributed execution engine while keeping the system structured for concurrency, persistence, observability, and long-term maintenance. My availability also overlaps with US, UK, and Australian business hours, supporting effective collaboration across your team. I would be glad to bring my Python, Linux, API, and architecture expertise to this high-throughput testing project. Choose me to help build a reliable internal platform for validating your proprietary protocols.


I’ve built Python asyncio services and Go workers for high-throughput API pipelines, including Redis-backed job coordination, TLS integrations, and latency telemetry. For this project, the key is a protocol client separated from the execution engine so signing, session renewal, pooling, and retries remain deterministic under heavy concurrency. I’ll implement HTTP/2 and TCP/TLS transport layers with AES/RSA/HMAC payload signing and explicit token lifecycle handling. I’ll build the distributed scheduler with asyncio or goroutines, Redis state, bounded worker concurrency, graceful backoff, and centralized structured metrics. I’ll also support configured egress interfaces and verify behavior with reproducible load scenarios, connection-error injection, and latency reports. Thanks, Kittipong


Hi there, Building a distributed API testing platform that handles high concurrency requires precise integration of asyncio or goroutines with Redis for task scheduling and state management. The key lies in implementing an HTTP/2 and TCP/TLS client that manages cryptographic payload signing seamlessly. A central challenge is ensuring network routing supports dynamic outbound interfaces while maintaining low latency and accurate metrics. I've designed similar systems in the past, focusing on concurrency and network protocol efficiency. Best Andrew


Hi, With 7+ years in web development, I have experience with Python, distributed backend systems, Redis, APIs, and Linux deployment. I can build your HTTP/2 and TCP/TLS client, cryptographic signing, distributed workers, configurable routing, and latency telemetry. What concurrency targets and protocol specifications should the framework support? Let’s discuss in chat to proceed further.


Hi there, I can build your distributed API testing and load-simulation engine using Python and asyncio, ensuring precise control over custom TLS handshakes, payload signing, and concurrent worker task scheduling via Redis. Having built high-throughput backend services and real-time communication systems, I understand the importance of efficient connection pooling, accurate latency tracking, and robust error recovery when benchmarking custom client-server protocols under heavy load. I will set up a clean, modular architecture that handles cryptographic payload signing cleanly while maintaining stable session token lifecycles across concurrent connections. We can design the execution engine to support configurable outbound network interfaces and centralized metrics reporting out of the box, making it straightforward to scale worker nodes and gather reliable performance telemetry on Linux servers. If you share your preferred protocol specifications and current testing bottlenecks, I can review the details and outline the initial implementation steps. Looking forward to working with you
内容来自 Freelancer News,版权归原作者所有。
阅读原文 ↗