AI-Powered Virtual Lab For Biotech R&D

Modernization and Development of an AI-Powered Virtual Lab For Biotech R&D

Industry

Biotech

Business Type

Startup

Main technologies

FastAPI, React

Services rendered

Web development, Python development

Engagement model

Staff augmentation

Project duration

Feb 2025-ongoing

Summary

SysGears provided Python development and modernization services to a startup building an AI-powered web platform for biotech research. Working as an extension of the client’s in-house development team, our engineer suggested a comprehensive approach for enhancing the solution’s performance, usability, and maintainability, which included:

Separating frontend and backend by migrating the monolithic Streamlit application to a FastAPI backend with a React frontend
Replacing file system storage with a relational database
Developing a single authentication service for all products within the client’s software ecosystem

About Our Client

Our client is a biotech startup developing a cloud-based web platform for simulating real-world laboratory experiments. The solution enables scientists to design and run experiments online with the help of built-in AI and robotics, significantly accelerating R&D as compared to traditional laboratory methods. The ultimate goal is to help customers make the research more cost-efficient and reach the market faster.

How Our Cooperation Began

The client’s company was preparing to launch the first version of their application and sought to hire a Python backend developer to assist their in-house development team with debugging and routine development tasks. Once the client reached out to SysGears, we carefully analyzed their requirements and suggested hiring our engineer with relevant experience in Python software development.

Shortly after our cooperation started, our specialist determined several critical issues that would have prevented the application from working reliably under real user loads.

Challenges We Identified During System Audit

An original technology stack became a limitation as the product evolved. The application was built with Streamlit — a Python framework, which worked well at the MVP stage, but proved unsuitable for a multi-user production environment.

This resulted resulted in:

Poor user experience: Given the Streamlit execution flow, each interaction triggered a page reload, so it took around 30 seconds to refresh the page.
Maintainability issues: The custom app design made it difficult for developers to add new features, leading to frequent regressions, bugs, and repeated rework.
Limited frontend flexibility: Streamlit offers a limited set of UI components and design patterns, so implementing more complex user flows became a challenging task.
Concurrency constraints: Streamlit is not optimized for multi-user scenarios, making it difficult for the application to handle a growing number of simultaneous users as the project scales.

Storing data in a file system was another reason the application was slow and prone to errors.

Our Tailored Approach

By partnering with SysGears for team augmentation services, the client gained not only an experienced specialist but also the support of the entire SysGears team. After reviewing the existing architecture, researching possible solutions, and consulting with colleagues, our Python developer evaluated the challenge from multiple perspectives and recommended migrating the application’s codebase from Streamlit to the FastAPI backend with the React frontend.

High-Level Solutions We Suggested

Architecture Decoupling

To improve the application performance and user experience, our specialist conducted a full architecture revamp, separating the backend from the frontend. The server side was migrated from Streamlit to high-performance FastAPI, and the UI was rebuilt with a more robust React framework. This enabled better scalability, lower latency, and higher concurrency, so the application is fast and responsive under multi-user workloads.

Gradual FastAPI Migration

The original codebase comprised a large, monolithic script that ran every time the user interacted with the application, making it slow and difficult to maintain as new features were added. Our Python engineer conducted incremental code refactoring, gradually replacing Streamlit with the modular FastAPI backend, which eventually gave developers more flexibility and control.

Data Migration From File System to Database

Our developer migrated data from the file-based storage system to a relational database (PostgreSQL), designing the database architecture from scratch. In particular, data normalization was conducted to reduce redundancy, minimize errors, and thus significantly improve the application’s performance and maintainability. Our engineer was also responsible for setting up a project structure, database connectivity, and other related tasks, enabling the client’s development team to balance workloads and work more efficiently.

Authentication Service Implementation

Since the project comprises multiple applications with a common user base, our developer introduced a central authentication service for the entire product ecosystem, so there is no need to maintain its own identity model and auth subsystem for every new app. Implemented with Auth0, the service uses passwordless login with email OTP, eliminating password risks and accelerating user onboarding. The authorization is app-specific: accessing one app doesn’t unlock the entire ecosystem.

Single Backend For Client and Admin Workflows

Previously, the solution consisted of separate admin and user applications. Our developer consolidated the system into a single backend with a unified API, where access to endpoints is controlled through role-based authorization. Such an approach enabled the team to reduce duplication while preserving the clear separation between administrative and user-facing functionality.

Incremental Feature Implementation

Client Request Handling

Our developer implemented a request management feature, enabling the platform’s clients to ask for specific chemicals, concentrations, and formulation recipes, as well as track request statuses, and view history. The admins were enabled to view and process requests with a few clicks.

Multi-Format Report Generation

Every experiment run in a virtual lab is accompanied by a results report, formulation details and analysis results. Our developer enabled report generation in multiple formats, making it easier for users to review, share, and analyze the outcomes.

Usage-Based Point System

The usage-based credit system was implemented, enabling platform admins to assign points to users and charge them for every experiment run.

Key Outcomes

The project is still in progress, and SysGears remains the client’s reliable staff augmentation partner. By now, the key results include:

10x faster page load times: Now that data is fetched on demand, app pages load in less than 3 seconds, significantly improving the user experience.
Better extensibility: Migration to FastAPI+React architecture made the solution less prone to errors when new features are added.
Enabled horizontal scalability: The decoupled architecture allows the system to run multiple instances, distribute services across several deployments, and efficiently use container orchestration tools like Kubernetes.
Cleaner project structure: By implementing a centralized authentication service and unifying user and admin workflows into a single backend, the development effort was significantly reduced for the client’s engineering team.
Improved maintenance: Migration to a more standard tech stack simplifies future maintenance, as the technologies are familiar to most software development teams.