Approximately 5 microservices on FastAPI + edits and refactoring

Budget: 1200 USD Deadline: 10 days

Regarding the price - 350 USD is enough for a short entry into the project, repository review, service launch, risk map, and 1 small MR. Completing subscription - billing with RevenueCat, abuse protection, notifications, analytics events, comments, gamification, deduplication, plus tests and refactoring for this amount is unrealistic. A realistic first engineering phase is 1200 USD and 10 working days, after which we can break it down by services.

Look, there’s a nuance - I opened Drive and the document with updates. It’s clear that MessageKit, Temporal, events between Flow Engine, Learning, and Automations, RevenueCat webhook, idempotent token log are important, not just CRUD. The Figma with current access needs to be additionally verified after granting view access. Overall, it’s fine, but without preliminary decomposition, it will be a lottery, and a lottery in billing is usually more expensive than development =/

Entry plan
> set up the project locally and check 11 services
> identify stable API contracts for the frontend
> close one priority block via GitLab MR
>> most often I would start with billing - RevenueCat - tokens - abuse, because that’s where the money is, webhook repeats, and security
> add unit and integration tests for critical scenarios
> provide a list of remaining services with stage estimates

Questions
> Is there access to GitLab, .env.example, docker compose, and test keys for RevenueCat?
> What is a higher priority for the first MR - billing or notifications?

Similar projects Ingello
> https://business.ingello.com/fractal - complex event architecture and agent processes
> https://business.ingello.com/platforma - corporate platform with roles, business logic, and integrations
> https://business.ingello.com/forma-bpm - processes, events, and managed logic

Main page of Ingello for FLH - https://systems-fl.ingello.com Expand

Budget: 350 USD Deadline: 2 days

Alexander, I see a complex but already well-assembled backend: this is exactly the case where careful refinement is important, not "rewrite everything." I can connect to FastAPI microservices, handle billing/subscription with RevenueCat, notifications, analytics, comments, and deduplication, as well as assist with abuse protection, testing, bug fixes, and refactoring. I have worked with API integrations and supported live projects. I am ready to go through the technical specifications and mockups and propose a clear plan.

Budget: 350 USD Deadline: 1 day

Good day! I develop in Python, have worked on similar projects with React/Node.js, and am ready for collaboration.

Budget: 350 USD Deadline: 1 day

Alexander, you already have a strong foundation, and it is important to carefully implement 5 microservices without breaking the current architecture. I can take on the FastAPI part turnkey: subscription/billing with RevenueCat, abuse protection, notifications, analytics events, comments, deduplication, and gamification, plus refactoring and missing endpoints. I have 7 years in web/mobile and experience with complex microservice systems. I am ready to join the MR process, tests, and quickly discuss the details.

Budget: 400 USD Deadline: 7 days

Good day.

We will do it professionally.

Our website: viacore.group

Budget: 2500 USD Deadline: 15 days

Hello. I have extensive experience with FastAPI. I am ready for collaboration. Feel free to contact me.

Budget: 350 USD Deadline: 1 day

Good day! For 350 USD, I can recommend a solid list of literature that will help you complete the project on your own. Feel free to reach out if this is relevant!

Budget: 350 USD Deadline: 14 days

Good day! I developed the backend using FastAPI microservices — billing with subscriptions and payment webhooks, notifications, event analytics, all through MR on GitLab with unit and integration tests. I connected Revenuecat on the server: receipt validation and renew/cancel webhooks. I am ready to finish the remaining services, starting with subscription/billing and abuse protection. I will check Figma and the technical specifications — one question: do you send events between services through a broker (Kafka/RabbitMQ) or simpler, through a Redis queue? This affects how to handle analytics events and deduplication.

Budget: 350 USD Deadline: 10 days

Hello! I am interested in your project. I have relevant experience and am ready to start soon. Please tell me a bit more about the task in private messages — we can discuss deadlines and costs.

Budget: 350 USD Deadline: 7 days

Hello! Backend on FastAPI with integrations is exactly what we do. Billing/subscription, payment provider webhooks, and RevenueCat, billing abuse protection (idempotency, protection against double charges, rate-limit) are our main areas.

I won’t promise all five services at once — that would be unfair on someone else's codebase. I suggest starting with the riskiest piece: subscription/billing + RevenueCat integration + abuse protection. I will analyze the current code and specifications with mockups, and I will close this service with the first merge request including unit and integration tests, so you can immediately see the pace and quality. Then, following the same scheme, we will tackle notifications, analytics events, comments, gamification, and deduplication.

A couple of questions: what Python and stack are under the hood (async SQLAlchemy? what for queues and broker)? Are tests on pytest? Is RevenueCat already connected in production or does it need to be set up from scratch — webhooks, entitlements?

I can show examples of our backend integrations live. As for timelines — I will close the first service a few days after gaining access to the repository.

Petr Pankov, BotCraft Group

Budget: 350 USD Deadline: 5 days

Hello. My name is Vladimir.

I am an experienced developer with 8 years of experience in creating turnkey websites, mobile applications, and complex web systems.

I specialize in developing modern, responsive, and high-performance solutions. Over 8 years of practice, I have built a deep technical stack:

Frontend and interfaces: HTML, CSS, JavaScript, TypeScript, React.js, Next.js, Vite, Tailwind CSS, Bootstrap, and Elementor.

Mobile development: React Native and Flutter.

Backend and API: Node.js, PHP, Python, Laravel, REST API, and GraphQL.

Databases and caching: MySQL, MariaDB, PostgreSQL, MongoDB, and Redis.

Infrastructure and tools: Git, Docker, Nginx, Apache, Composer, and Linux (Terminal).

I effectively analyze client requirements, propose optimal architectural solutions, and strictly adhere to deadlines. In addition to development, I possess skills in design, technical SEO optimization, and project support. Expand

Budget: 350 USD Deadline: 5 days

Good day!
The five remaining services are precisely those where it's easiest to mess up - billing with RevenueCat and abuse protection nearby. Most often, the problem isn't with the webhook handler itself, but rather that the client and server diverge in the subscription state during network failures or callback duplicates - therefore, the subscription state should be maintained as the server-side source of truth, and RevenueCat events should be processed idempotently.

Deduplication and analytical events are essentially one task on the event key + TTL storage (Redis will do), which can be reused for notifications and comments, rather than creating a separate deduplication for each service.

I have experience with FastAPI microservices, billing integrations (RevenueCat/Stripe), push notifications, as well as refactoring someone else's semi-finished code and improving test coverage (pytest, unit + integration). The GitLab flow with MR and review is a familiar process.

I will send a brief analysis of the Figma layouts and a draft sequence of work for the services (billing entails abuse prevention and part of notifications) in personal messages - it will be more convenient to verify details regarding the already completed 11 services there.
We can agree on project details in private.

Budget: 350 USD Deadline: 7 days

Hello, Alexander! I am ready to join the project right now and complete the remaining 5 microservices on FastAPI strictly within your budget.
My advantages that will address your tasks:
Deep experience with asynchronous FastAPI: I develop asynchronous network cores and microservices. I have a great understanding of working with sessions, dependency injection (Depends), and middleware.
Implementation of billing (RevenueCat): I will write a clean asynchronous webhook handler for RevenueCat. I will implement idempotency checks for requests (to avoid double charges/deductions on repeated requests from the payment gateway).
Abuse Protection & Rate Limiting: I will set up billing protection against spam requests and brute force attacks via Redis (using the Token Bucket or Leaky Bucket algorithm) — this will prevent attackers from overwhelming your payment gateways.
GitLab & Testing: I work through clean Merge Requests on GitLab, write automated tests using PyTest (utilizing fixtures, mocking external APIs with unittest.mock, so that tests do not depend on external servers).
I am 100% available and ready to commit code from day one without delays. Let's connect in private messages, I will take a look at your repository and specifications, and we will finalize the development plan!

Budget: 350 USD Deadline: 7 days

Hello. I am ready to take on your order if you haven't found anyone else yet. We can discuss all the details in private messages. The cost is $250, and I can complete it in 5-7 days.

Budget: 1000 USD Deadline: 10 days

Alexander, good afternoon!

I looked at the specifications on Drive, the document with updates and Figma mockups — the task is clear: to complete the remaining ~5 microservices (subscription/billing with RevenueCat, abuse protection, notifications, analytics events, comments, gamification, dedup) in the already half-finished system with ~11 services on FastAPI, with tests, refactoring, and pushing through MR in GitLab.

Honestly about the budget: 350 USD will only be enough for the entry into the project — to raise the services locally, read the codebase, create a risk map, and make the first small MR. A realistic first engineering stage is about 1000 USD / 10 working days (for example, closing billing with RevenueCat + abuse protection with tests), then we break it down by services with a fixed price for each. This way you can see the quality of the code before investing the entire budget.

How I work: MRs are small and clear, unit and integration tests for each new piece, I don’t break anything working in existing services, green GitLab CI before merging.

I work with Python/FastAPI; I provide transparent MRs and pauses for your confirmation between stages. I am ready to start with an audit of the repository and the first MR.

Budget: 350 USD Deadline: 30 days

I see that the project for an educational platform based on microservices is an interesting task, especially considering that some services are already ready and need to be organically integrated into the existing architecture.

From the description, I understand that the main work is focused around billing/subscription with RevenueCat, notifications, gamification (partially ready), and a deduplication service. This is not just about writing from scratch, but making sure that all of this fits well with the other ~6 services. I have about 3.5 years of commercial development experience, having worked on products with similar tasks: integrations with payment providers, notification services, analytics systems. I know FastAPI, and I have experience with clean architecture and DI.

Regarding testing: I am ready to cover new services with unit tests from scratch and to add integration tests where they are currently missing. Refactoring existing code is a familiar part of my work, not something extra.

I am ready to discuss the details of each of the remaining services to immediately estimate the volume and priorities.

Budget: 350 USD Deadline: 1 day

Good day.

I have commercial experience in backend development using Python/FastAPI, PostgreSQL, Docker, and working with existing projects and API integrations.

I have reviewed the description. From my experience, the most critical aspects here seem to be subscription/billing, integration with RevenueCat, handling webhook events, and protection against duplicate operations. I also have experience in refining existing functionality, writing tests, bug fixes, and working through GitLab Merge Requests.

For an accurate assessment, I would like to first review the repository and the current state of the services. After a brief audit, I will be able to propose a realistic work plan and stage-wise estimation.

I would be happy to discuss the details.
Sergiy

Budget: 350 USD Deadline: 10 days

Hello, Alexander! My name is Alexander. I am a Senior Backend Developer (Python) specializing in designing and refactoring fault-tolerant asynchronous microservice architectures based on FastAPI.

I have studied the educational platform project similar to Mimo/SoloLearn. The tasks of completing the remaining 5 microservices, integrating payment and analytics gateways, as well as deduplication are completely clear. I have extensive experience working with complex business logic and integration APIs.

My technical stack and approach to implementing your tasks:

1. MICROSERVICE ENHANCEMENT (FastAPI / Asyncio):
— Subscription/Billing & RevenueCat: I will implement a clean asynchronous integration with the RevenueCat API for handling subscriptions (webhooks, receipt validation, user status synchronization).
— Abuse Protection: Building billing protection logic based on request limiting (Rate Limiting using Redis/In-Memory) and behavioral scoring of requests.
— Notifications & Analytics Events: Optimizing the event bus. Setting up asynchronous sending of push notifications and logging analytics events without blocking the main event loop.
— Dedup & Gamification: Writing efficient SQL/NoSQL deduplication algorithms and logic for awarding points for comments/missions.

2. REFACTORING, TESTING, AND COMPLIANCE:
— Code Coverage: Writing quality Unit and Integration tests (pytest / httpx.AsyncClient / pytest-mock). I will bring the test coverage to a stable production level.
— Bug Fixing: Conducting an audit of the current code of 11 microservices, fixing integration bugs with the frontend, and adding missing endpoints according to Figma layouts.
— GitLab CI/CD: Full compliance with your Git-flow. Creating clean commits, working in separate branches, and providing structured Merge Requests (MR) with descriptions of changes.

The cost of the turnkey stage is 350 USD. The timeframe is 10 days, including thorough testing and revisions. I am ready to review the technical specifications on Google Drive, Figma layouts, and set up a local environment through a secure deal via Safe. What database (PostgreSQL, MongoDB) and message broker (RabbitMQ, Redis) is currently used for communication between your 11 microservices? Expand

Budget: 2400 USD Deadline: 14 days

We already have a nearly ready similar setup for FastAPI microservices, RevenueCat, and event-driven architecture, which can be quickly adapted for your project. We can discuss it here now; I'm available.))
Regarding the price - 350 USD for this volume will likely not even cover the initial analysis; I would estimate a normal starting phase at 2400 USD for 14 days.
We would start with a short audit of the current services, then close subscription and billing through the RevenueCat webhook as the source of truth, token ledger, abuse protection, notifications, analytics events, comments, deduplication, and gamification enhancements.
I noticed an important nuance in the technical specifications - events should connect the Flow Engine, Learning, and Automations through MessageKit, and some processes seem to need to remain idempotent; otherwise, billing will retaliate with accounting.
We need access to GitLab, the current environments without secrets in the exchange chat, the deployment scheme, a list of already prepared services, and access to view Figma, because currently, the link through the tool requests editor rights.
After this, we can provide a precise breakdown of merge requests and risks.
Questions to make the estimate more accurate:
- Do we keep the RevenueCat webhook as the sole source of truth for subscriptions and token top-ups, and do we not consider frontend success as confirmation of payment?
- For tests, do we need a minimal set for critical flows, or do we cover each new service with unit and integration tests up to GitLab merge requests?
Relevant examples:
- https://business.ingello.com/ibla - EdTech backend, close in server logic to the educational platform.
- https://business.ingello.com/drone - prototype of an educational application, similar in product mechanics of learning.
- https://business.ingello.com/vorfahr - SaaS with AI and payments, indirectly close in architecture and integrations.
Main FLH landing Ingello - https://systems-fl.ingello.com Expand

Budget: 4500 USD Deadline: 50 days

Looks like big project and it will take more time once continue progressing project.

Budget: 350 USD Deadline: 7 days

Hello. I can help you with your task. Feel free to message me privately. I will do everything quickly and efficiently.

Budget: 350 USD Deadline: 2 days

Worked with a similar architecture: several microservices on FastAPI, billing through RevenueCat, abuse protection at the subscription level. I understand that subscription/billing is likely tied to webhooks from RevenueCat plus its own subscription state logic, and abuse protection will require rate limiting and behavior pattern checks. Please clarify: should notifications be done through your service or is there an already chosen provider (Firebase, OneSignal, something else)? I am ready to discuss the details and look at the current code.

Budget: 350 USD Deadline: 5 days

Hello

I can help you complete and stabilize your FastAPI microservices architecture for your educational platform, including the remaining services for billing, subscriptions with RevenueCat, notifications, analytics events, comments, gamification, deduplication, and abuse protection.

I have experience working with distributed FastAPI systems and microservice based architectures where reliability, event consistency, and clean service boundaries are critical, especially in production environments with multiple frontend integrations.

For your billing and subscription layer I can implement robust RevenueCat integration with proper webhook handling, state synchronization, and abuse prevention logic to protect against fraud and edge cases. I can also ensure idempotency and safe retries across services.

For notifications, analytics, comments, and gamification I can complete the missing endpoints, align them with your existing architecture, and ensure consistent API contracts so the frontend remains stable even as backend services evolve.

I also work comfortably with unit and integration testing, refactoring partially completed services, and improving existing codebases without breaking current functionality. I can support manual QA, fix frontend related backend issues, and ensure smooth MR based collaboration in GitLab.

I am comfortable working from Figma as the primary source of truth and aligning backend behavior to match product design requirements precisely.

Thanks, Hanh Expand

Budget: 350 USD Deadline: 7 days

Good day!

I professionally develop web applications and microservices in Python. I am ready to complete your educational platform on FastAPI: implement billing (RevenueCat), analytics services, gamification, and notifications, cover the code with Unit/Integration tests, and manage tasks through GitLab MR + deploy the project on the server.

Message me privately, and we will clarify the details.

Budget: 1000 USD Deadline: 30 days

Good day! I specialize in FastApi, and judging by the provided specifications, as many have mentioned here, staying within a budget of $350 and delivering quality is unrealistic.
If we consider a rough estimate, we can look at around $1000. If you are willing to discuss such a budget, I can create a complete specification for the development, breaking it down into points and time estimates.
Once we agree on the complete specifications and the cost, we can get started.
You also mentioned that a lot is ready but needs finishing. For the assessment, I need the code to understand how things are organized and what is ready.
A simple example regarding the quality of the application: if an old version of Uuid is used, its formation is completely unique, and when inserting it into the database, problems arise, even with indexing (distribution of records in the database and, accordingly, searching, querying, etc.). If v7 is used, there is no such problem, as the beginning of the record is formed as a timestamp and everything is in its place. If PostgreSQL 18 is used, this field should be formatted by the database itself, as this functionality is already available and optimized there.)
This example shows that with $350, such issues will likely be overlooked, meaning you will not receive quality but rather a slowdown of the entire system in the future.
A quality product should be paid for accordingly, and when refining projects, it also requires an audit by a new developer, which is not free either!
Good luck in your search, if anything, feel free to write, and we can discuss.

Budget: 350 USD Deadline: 10 days

Hello. I can do your project. I have experience. Write to me and we will agree.

Budget: 350 USD Deadline: 5 days

Hello Alexander! We have thoroughly studied the attached API diagrams, xAPI Statements specifications, and MessageKit requirements. The platform is designed very intelligently, and we fully understand the architectural approach to complete isolation of the content layer.

It would be unfair to deliver all 5 services for $350 on someone else's codebase with such a dense microservice framework (where a hybrid generation pattern, xAPI Actor Management, and a custom Flow Engine are involved) in relation to quality. We propose to proceed in sprints through GitLab MR with phased payments.

As Valentin (Python / FastAPI) implements the First Stage (Billing and Abuse Protection):
Microservice Subscription/Billing & RevenueCat: We will connect the endpoint /api/v1/billing/revenuecat/webhook. We will set up strict validation of the RevenueCat authorization header, deduplication by event_id, and asynchronous processing of subscription lifecycle events. Token accrual (virtual currency) is strictly tied to the VIRTUAL_CURRENCY_TRANSACTION event on the backend with immutable logging (ledger records), with the frontend excluded as the source of truth.

Abuse Prevention: We will develop the microservice /api/v1/abuse/status. We will protect billing from fraud, time manipulation, and duplicate charges by implementing strict idempotency and limits.

Testing and MR: We will write new integration and unit tests using pytest, check backward compatibility to ensure that the billing logic does not affect the already completed gamification service, and send a clean Merge Request in GitLab.

Conditions:
The budget of 350 USD is approved as payment for the First Stage (Billing + Abuse Protection + Tests).

Deadline - 5 days from the moment of receiving access to the repository and GitLab CI. We will evaluate and close subsequent services (Notifications, Analytics Events, Comments, and gamification improvements) in separate sprints.

Alexander, for preserving history and tokens, do you use PostgreSQL (via asyncpg) or is MySQL allocated for this microservice as specified in the basic requirements?

Let's communicate in the chat, Valentin is ready to receive access and set up the test environment! Expand

Budget: 450 USD Deadline: 10 days

Hello, Alexander.
I read the specifications with updates and went through the layouts in Figma. I'll get straight to the point.
The main risk here is not the number of services, but the subscription/billing with RevenueCat. It's critical to ensure the idempotency of webhooks and subscription states: trial, grace period, renew, cancel, refund, to prevent duplication and loss of funds. Alongside this is abuse protection: protection against double charges, rate-limiting, and webhook signature verification. The same logic applies to analytics and deduplication, ensuring event idempotency against duplicates.
Therefore, I do not suggest tackling all five services at once on someone else's codebase. I will take on the first phase of subscription/billing plus RevenueCat plus abuse protection and will close it with one clean MR on GitLab with unit and integration tests, so you can immediately see the pace and quality. Following the same scheme, notifications, analytics with deduplication, comments, and refining gamification will follow.
Regarding the budget, to be honest: the entire remaining volume with tests, refactoring, and front-end support is not work for 350. This is several weeks of intensive development, so I will work in phases, with payment per phase. I will provide exact figures for each module after gaining access to the repository; without it, the estimate will be guesswork.
What I have done exactly on this topic (screens attached):
1. A product platform with usage/billing logic, queues and retries, event idempotency, typed contracts, and testable API boundaries. The same core as in your billing, analytics events, and deduplication.
2. An internal CRM/ERP with financial operations, roles, audit trail, and rollback for sensitive write actions, plus regression tests. Directly related to safe financial operations and abuse protection.
3. A Telegram Mini App with subscription premium/boost mechanics, limits, and notifications via a bot. This is subscription logic and notifications.
My main stack is Python and FastAPI, async, PostgreSQL, queues and workers, payment system webhooks, tests on pytest. Code on GitHub: github.com/vitalivo.
Questions to clarify for an accurate estimate:
1. What is the communication method between services, RabbitMQ or Redis, and where does Temporal fit in?
2. Is RevenueCat already in production or are we starting from scratch, is there a sandbox for webhooks?
3. Is there CI on GitLab and what are the expectations for test coverage?
I am ready to start with billing as soon as I gain access to the repository. Expand

Budget: 350 USD Deadline: 7 days

Good day, Alexandr!

I noticed your project and see that it truly requires a comprehensive approach. I would be happy to assist you in refining the microservices on FastAPI and making the necessary changes to ensure your educational project becomes even more successful.

- ⭐689% traffic growth in 3 months!⭐ - https://freelancehunt.com/showcase/work/689-prirostu-trafiku-za-misyatsi/1993127.html
- ⭐Clothing print company. Traffic growth of 486%⭐ - https://freelancehunt.com/showcase/work/magazin-dlya-doroslih-zrostannya-prodazhiv-na/1993118.html
- ⭐Traffic growth of 4854% in 15 months. Want the same?⭐ - https://freelancehunt.com/showcase/work/zrostannya-trafiku-na-4854-za/1993112.html

At this stage, I need more information to propose an optimal solution. Please clarify:

- What deadlines do you plan for completing the remaining microservices?
- Do you have preferences for tools or libraries for integration with Revenuecat and other tasks?
- Do you have specific requirements for testing and refactoring?
- Is there anything to consider during development to align with future platform expansion plans?

The cost and timeline for development are influenced by several factors:

1. The volume and complexity of the remaining microservices that need to be completed.
2. The necessity of integration with Revenuecat and other systems.
3. Testing requirements: manual testing and adding new unit tests.
4. The volume of work for refactoring and bug fixing.
5. Additional integrations and adjustments that may arise during the work.

Looking to the future, we will need to formulate and agree on a final vision of the end result of the microservices development, which we will reflect in the technical assignment. I prefer to build such a vision based on the analysis of existing solutions and your unique wishes. This will allow us to understand how similar projects have been implemented by competitors, take useful ideas, and improve upon them.

Your project represents a complex educational platform that requires a deep understanding of microservices architecture and integrations. I have experience in development with FastAPI and can help you refine and optimize the system, taking into account all nuances and future expansion plans.

The next step is to discuss the project details and understand how well we fit together. Let's finalize the details in correspondence or at a meeting. Expand

Budget: 10000 USD Deadline: 90 days

Hello!

I read the technical specifications and looked at the layouts. To be frank, the scope here is clearly larger than the stated budget. Subscription/billing with RevenueCat, abuse protection, notifications, analytics, comments, likes, deduplication, and gamification implementation is not just "adding a couple of services"; it requires several weeks of intensive work from a senior developer, plus testing, refactoring, and front-end support during integration.

For $350, such a project cannot be fully completed by anyone who promises that; either they haven't understood the specifications, or they will abandon it halfway. Realistically, this is a job for 1.5 to 2.5 months, and the budget should be appropriate.

I am ready to take it on properly: in stages, through merge requests on GitLab, with tests, starting with the most risky module (billing + RevenueCat). I will provide exact timelines and pricing for each stage after gaining access to the repository; without it, any estimate would be guesswork.

If the budget is negotiable, please write, and we can discuss the details.

Budget: 350 USD Deadline: 5 days

Hi, Alexandr hope you are doing well

I can help complete the remaining services using FastAPI Temporal messagekit and the existing project libraries. I can work with RevenueCat subscription logic billing abuse protection notifications push and email integrations analytics events comments likes dislikes lesson generator quiz integration duplicate finder and gamification improvements.

My approach would be to first review the current services specs Figma GitLab repo and existing contracts then finish missing endpoints add event contracts connect services through HTTP and events where appropriate and make sure frontend needs are covered.

I can also add unit and integration tests perform manual testing fix bugs refactor weak parts and submit clean merge requests with documented changes.

Best regards
Youssef.

Budget: 350 USD Deadline: 7 days

Hello.
I am ready to join the project as a Python/FastAPI backend developer.
I work through GitLab MR, can add unit/integration tests, carefully refine existing FastAPI services without rewriting the project from scratch, and assist frontend developers with missing endpoints.

Budget: 600 USD Deadline: 14 days

Hello. I am ready to join the project and help complete the backend part on FastAPI. I have experience with APIs, microservice architecture, integrations, testing, refactoring, and working through GitLab/MR. I can understand the current codebase, improve billing/subscription, notifications, analytics, comments, gamification, and other services according to the specifications and mockups. I am ready to discuss the details and start with project analysis.

Budget: 350 USD Deadline: 7 days

The most important thing here seems not to be the number of remaining microservices, but to understand the current architecture, close billing and subscriptions, finish the remaining services, tidy up the tests, and calmly support the frontend as integration progresses. In such projects, a lot of time is usually spent on the integration between services and finding hidden problems, rather than writing new code.
I really like the topic of educational platforms; I once went through training via similar services and understand well how important the stability of subscriptions, notifications, and user progress is.
Could you please let me know if the project is already deployed in a test environment and if all existing services can be run locally without issues? And what is the current readiness percentage for subscription/billing and gamification relative to the rest of the project? I'm also curious if a person is needed for full focus until release or if the work is planned to be done in parallel with other contractors?

Budget: 350 USD Deadline: 20 days

Hello, Alexander!

The educational platform project is very cool and large-scale, the stack FastAPI + PostgreSQL is my main profile. I fully understand the architecture of such systems and how easily everything can fall apart on the front end if the backend returns inconsistent JSON.

Understanding the volume of tasks (especially the idempotency logic of RevenueCat webhooks and event deduplication in analytics), I suggest not doing everything in one huge chunk, but breaking the work into iterations through GitLab MRs.

I propose to start with the most critical module — Subscription/Billing + RevenueCat. I will implement subscription state handling, webhooks, and close the task with clean code and Pytest tests, so that the front-end developers can seamlessly connect right away.

I am ready to discuss technical details (which message broker is used for events — Redis or RabbitMQ?) and distribute tasks by stages in Safe. Looking forward to hearing from you!

Budget: 350 USD Deadline: 4 days

Hello, I have extensive experience working with FastAPI, as an example https://zem.center/, I wrote the entire backend here using FastAPI. I can complete the necessary microservices without any problems, my GitHub: https://github.com/onyx144

Budget: 350 USD Deadline: 1 day

Hello!

I am interested in the project — I have wanted to work with such architecture for a long time: FastAPI microservices, events through messagekit, Temporal as the linking element between services. I have read the specifications and the update document carefully, the approach is clear, and I have no particular questions about the architecture.

I think the most challenging part here is the Subscription/Billing with RevenueCat: we need to properly handle the idempotency of webhooks and subscription states (trial/grace period/cancel) to ensure nothing is duplicated or hangs. I also see the rest of the scope — abuse protection, notifications with push, analytics events, comments, gamification enhancements, deduplication. The volume is considerable, but entirely feasible.

I have a few clarifying questions about the details (RevenueCat, access to repos/CI, expectations for test coverage) — it would be more convenient to discuss them privately. Payment will be staged, based on the actual hours worked. Once we finalize all the details, I will provide the exact timeline and price for the project.

I look forward to collaborating!

Budget: 900 USD Deadline: 30 days

Hello, Alexandr! I am ready to complete your project: "5 microservices on FastAPI + edits and refactoring"... Write to me, and we will discuss the details!

Budget: 350 USD Deadline: 14 days

Greetings! I have analyzed the structure of the "Coding Train APP" based on the Figma layouts; I will set up a reliable integration with RevenueCat, develop abuse protection for billing, and implement the other microservices on FastAPI with Pytest coverage. When creating GitLab MRs, I will ensure strict backward compatibility so that new gamification or deduplication controllers do not disrupt the logic of already functioning modules. Within the specified budget of 350 USD, I will prepare fully tested services ready for seamless integration with your frontend. How is the inter-service communication currently organized — through a message broker (RabbitMQ/Redis) or direct gRPC/REST? Please send access to the repository in private messages — I will thoroughly review the code and immediately start on the first ticket.

Budget: 1200 USD Deadline: 21 days

Hello! Serious backend project - microservices architecture based on event-driven approach with Temporal orchestration, I have worked on such systems. Questions:

Is there access to the GitLab repository to assess the quality of the existing code before starting? RevenueCat - webhook-based or directly through the SDK?

Budget: 350 USD Deadline: 30 days

Hello. I reviewed the composition of services: subscription/billing with RevenueCat, abuse protection, notifications, analytics events, comments, gamification, dedup. I work closely with FastAPI and such integrations. For RevenueCat, I implemented webhook signature validation, event idempotency, and handling of renewal/refund/grace period.

Regarding the process: I work through MR on GitLab, write unit and integration tests for new code, and run existing tests before merging. I also handle refactoring and adjustments for the front end.

To provide an accurate timeline estimate, I will look at the technical specifications and Figma. A couple of questions: what stack is around (DB, queues, service authorization) and is there CI on GitLab?

I am ready to start after agreement.

Budget: 350 USD Deadline: 1 day

Hello! I will complete your task quickly and efficiently.

My recent works
https://indexfast.pp.ua - fast website indexing
https://mono-bank.pp.ua - everything about Monobank
https://mamamia.pp.ua - online store
https://programist.pp.ua/ua/portfolio/ - portfolio of works
https://monitortest.pp.ua - monitor testing
https://keytest.pp.ua - keyboard testing
https://pctest.pp.ua - computer testing
https://vseetut.matviy.pp.ua - layout

My portfolio: https://freelancehunt.com/ua/freelancer/romas6ka.html#portfolio
Message me, I will start working today. I will be glad to collaborate with you! Expand

Budget: 350 USD Deadline: 14 days

Good day! We have experience in developing high-load systems on FastAPI. We implement the missing microservices, including billing with Revenuecat and an abuse protection system, through asynchronous architecture and clean code. We will conduct a quality refactoring of the current codebase to ensure project stability.

Budget: 350 USD Deadline: 1 day

Hello. I am ready to take on the improvement of existing microservices and the development of new ones, focusing on ensuring the stability, scalability, and security of the system. In particular, for billing with RevenueCat and protection against abuse, I will apply architectural patterns that guarantee data integrity and compliance with security requirements, as well as optimize interaction between services. My experience in developing complex microservice architectures on FastAPI, particularly in financial and educational projects, allows me to effectively integrate third-party services and use ready-made templates to accelerate development and testing. I will pay significant attention to writing new unit and integration tests, refactoring and optimizing existing code, as well as manual testing to ensure the flawless operation of the entire platform. I suggest discussing all implementation details, the final budget, and timelines in private messages.