Pathflow

A living pathology laboratory operating system built by a practicing pathologist in Ethiopia using Codex to solve real workflow, reporting, inventory, and turnaround-time problems.

Comment

Inspiration

I live and work in a small town in Ethiopia, where access to specialized technology is limited by both geography and cost.

Opening a pathology laboratory practice here has required solving many problems that larger institutions often address through expensive commercial systems, dedicated IT teams, and established infrastructure. In my setting, those resources are not always available. Yet the need for accurate case tracking, timely reporting, inventory control, and reliable patient records is just as real.

As a practicing pathologist, I understood these problems intimately. I knew where cases became delayed, where records became fragmented, where supplies were difficult to monitor, and where staff repeated work. What I did not have was formal software-engineering training or the financial capacity to commission a custom laboratory information system.

ChatGPT, Codex, and GPT-5.6 changed that journey.

They did not give me the pathology knowledge or decide what the laboratory needed. They gave me a way to translate the knowledge I already had into working software. Through natural-language collaboration, testing, correction, and repeated refinement, I was able to build PathFlow around the realities of my own practice.

PathFlow began as an attempt to make one small laboratory more organized and dependable. It became proof of a larger idea:

When domain experts are given powerful coding tools, geography and limited access to traditional software-development resources do not have to prevent them from building solutions to the problems they understand best.

What It Does

PathFlow is a role-based pathology laboratory workflow and resource-management platform.

It currently provides:

  • separate privileges and interfaces for employees, administrators, and pathologists
  • pathology case registration and workflow tracking
  • predictive search for gross and microscopic description templates
  • faster retrieval and editing of standardized reporting text
  • patient-record similarity alerts using names and telephone numbers
  • inventory tracking
  • calculation of resource expenditure per case
  • turnaround-time monitoring and statistics
  • automatic red highlighting of unresolved cases that remain pending for more than four days
  • filtered case analytics by date range, pathologist, clinic, age, tumor site, and diagnosis
  • clickable summary statistics that open the exact underlying case list

The patient-matching feature provides a similarity score to help authorized users identify potentially related records.

The overdue-case feature gives both administrators and pathologists an immediate visual warning when a case exceeds the laboratory’s operational turnaround-time target.

How I Built It

PathFlow was built using:

  • Python
  • Flask
  • PostgreSQL
  • SQLAlchemy
  • HTML, CSS, and JavaScript
  • Visual Studio Code
  • OpenAI Codex
  • GPT-5.6
  • Gunicorn
  • Waitress
  • Railway

I began by describing the real laboratory workflow, including the responsibilities of each user, the movement of a case through the laboratory, the information that needed to be stored, and the points where delays or errors commonly occurred.

Codex served primarily as my software-engineering partner. It helped me:

  • translate workflow requirements into database models and application logic
  • create and modify PostgreSQL tables
  • build role-based routes and interfaces
  • connect frontend forms with backend operations
  • improve database queries
  • debug errors
  • add new workflow features
  • rapidly test and refine changes
  • prepare the application for deployment

GPT-5.6 served primarily as a product, reasoning, debugging, and deployment partner. It helped me:

  • organize the product concept
  • prioritize features
  • interpret technical errors
  • troubleshoot PostgreSQL and Railway deployment
  • structure the README and Devpost submission
  • plan the demo video
  • explain technical steps in a way I could understand and execute

I remained responsible for defining the pathology workflow, deciding which features were clinically and operationally meaningful, reviewing the output, testing the application, and determining whether each change matched the needs of the laboratory.

Pre-existing Work and Build Week Contributions

PathFlow existed as an earlier working prototype before Build Week. The core application already included pathology case registration, role-based access, reporting workflows, template search, patient-record matching, inventory tracking, and resource-cost analysis.

During the July 13–19 Build Week period, I used Codex and GPT-5.6 to make significant product, analytics, deployment, and documentation improvements.

July 17: Workflow Monitoring and Analytics

  • changed pending-duration calculation to use the case’s Date Received
  • added automatic red highlighting for unresolved cases pending more than four days
  • made overdue cases visible to administrators and the assigned pathologist
  • added overdue totals to pending summaries, grouped tables, and detailed case lists
  • expanded administrator statistics with filters for:
    • date range
    • pathologist
    • tumor-site keyword from the Index field
    • diagnosis keyword from the Index field
    • inclusive minimum and maximum age
  • added a Clear Case Filters action
  • made administrator statistics totals clickable by:
    • case type
    • pathologist
    • requesting clinic
  • added exact filtered case lists showing demographics, Index, clinic, pathologist, and sign-out date

July 18: Deployment and Project Configuration

  • added Gunicorn and Waitress for production serving
  • updated and pinned Python dependencies
  • migrated PostgreSQL connectivity to Psycopg 3
  • added support for Railway-style postgresql:// database URLs
  • made DATABASE_URL a required environment variable
  • created the initial Git project baseline
  • deployed the application to Railway with PostgreSQL
  • initialized the hosted database
  • created and tested fictional judge accounts for all three user roles
  • expanded the README with setup instructions and Build Week documentation

The submitted Codex session ID documents this recent Build Week development work rather than the original creation of the entire application.

Challenges I Ran Into

One of the largest challenges was translating a complex real-world laboratory workflow into clear software rules.

Different users require different privileges. Employees need to register and process cases, administrators need operational and inventory visibility, and pathologists need access to cases requiring review and action. Building these roles without creating confusing or unsafe access required repeated refinement.

Another challenge was patient-record matching. Names can be spelled differently, telephone numbers may be entered inconsistently, and more than one person may share similar identifiers. For this reason, the application treats matches as similarity alerts rather than confirmed identities.

Inventory and cost tracking also required connecting laboratory resources to individual cases. The system needed to record not only what was available, but how much was consumed and how that consumption contributed to the cost of each case.

A further challenge was making rapid changes without damaging a working application. Codex made iteration much faster, but every modification still required human review and testing.

Deployment introduced additional problems involving PostgreSQL drivers, environment variables, production-server configuration, missing tables, and user-role initialization. Solving these issues taught me how differently a local application can behave after being moved into a hosted production environment.

Accomplishments That I Am Proud Of

I am proud that PathFlow is not only a concept or interface mock-up. It is a deployed application with:

  • a working PostgreSQL database
  • role-based user accounts
  • structured case registration
  • pathologist reporting and case sign-out
  • pending and overdue case tracking
  • searchable pathology templates
  • probable patient-record matching
  • case analytics and turnaround-time statistics
  • inventory monitoring
  • resource-cost analysis
  • a public demonstration environment

As a practicing pathologist without formal software-engineering training, building and deploying a functioning laboratory platform was previously beyond what I believed I could accomplish.

What I Learned

The most important lesson was that domain expertise can become a powerful software-development advantage when combined with AI-assisted coding.

A professional software developer may understand programming better than I do, but I understand the pathology workflow, the practical constraints of the laboratory, the needs of the users, and the consequences of delayed or fragmented processes.

Codex did not replace that knowledge. It allowed me to convert it into software.

I also learned that building the first version is only part of the value. The greater transformation is that the application can now evolve continuously.

When I identify a workflow problem, I no longer have to wait for an external vendor or a long software-development cycle. I can describe the problem, work with Codex, review the implementation, test it, and improve the application rapidly.

This creates a living laboratory platform that can evolve with local needs, staff feedback, available resources, and changing workflows.

I also learned practical concepts in Flask, PostgreSQL, SQLAlchemy, Git, GitHub, Railway, environment variables, database initialization, production deployment, and debugging hosted applications.

Most importantly, I learned that AI coding tools do not eliminate the need for domain expertise, judgment, testing, or responsibility. They amplify the ability of a domain expert to build.

Why This Project Matters

PathFlow is personal testament that AI is no longer touching only the lives of people in wealthy cities or major technology centers. It is reaching even small, remote towns like mine in Ethiopia, crossing barriers of geography, finance, and limited access to specialized expertise. What once felt impossibly far away has become part of my daily work and has helped me turn an idea born from the struggles of my own laboratory into a functioning solution. AI did not arrive here as an abstract promise; it arrived as a practical force that made my journey easier, expanded what I believed I could do, and gave me the ability to improve the place where I live and work. It is both exciting and humbling to realize that I am participating, in my own small way, in one of humanity’s greatest evolutions that is comparable in significance to the industrialization, electrification, and the rise of the internet. Those revolutions proved and effectively multiplied what the human race is capable of building and achieving. Today, AI is beginning to do the same, and I feel deeply privileged to be part of this lucky generation that has seen this technology change humanity in real time.

PathFlow is more than a database application. It represents a different model of software creation.

I was not a software engineer searching for a healthcare problem. I was a pathologist living with the problem every day, in a place where buying or commissioning a tailored system was difficult.

Codex allowed me to cross that gap.

For professionals working far from major technology centers, the barrier is often not a lack of ideas or domain knowledge. It is the lack of accessible engineering capacity. AI-assisted coding can place that capacity directly in the hands of the people closest to the problem.

This is especially important in resource-constrained settings, where specialized developers, funding, and commercial laboratory systems may be difficult to access.

What Is Next for PathFlow

The next planned improvements include:

  • automated and tested backups
  • barcode integration
  • digital pathology integration with AI assisted image analysis
  • AI integrated case clustering and microscopic description analysis
  • stronger privacy and security controls

The long-term goal is to develop PathFlow into a secure, adaptable pathology laboratory operating platform designed around the realities of resource-constrained healthcare environments.

Built With

Share this project:

Updates