AI-Enabled Engineering Modernization for a DNA Testing Platform

The challenge

The platform had been built over several years by engineers and domain experts who understood canine genetics deeply. That domain expertise was genuinely reflected in the implementation — breed probability calculations, allele-based health marker scoring, lineage-aware result interpretation, and registry eligibility logic were all implemented with real accuracy. What had not kept pace was the engineering architecture supporting that logic.

Genomics domain logic was embedded throughout the codebase without explicit service boundaries. Breed probability models and health marker scoring routines appeared in serializers, view-layer handlers, and processing functions — interleaved with validation, persistence, and API response formatting in ways that made any single behavior difficult to isolate or test. The API surface had grown incrementally over multiple product cycles, with endpoints accumulating multiple responsibilities that reflected the order in which features were built rather than a coherent design.

Test coverage was sparse. This was partly structural: when domain logic is tightly coupled to serializers and view handlers, writing a focused test for the probability calculation requires exercising the full API surface, which makes tests slow, fragile, and expensive to maintain. The absence of behavioral coverage meant that changes to the core genomics processing logic — allele interpretation, health marker weighting, result classification — carried genuine risk of undetected regressions in a context where result accuracy had direct downstream consequences for customers and their animals.

CI/CD existed in a minimal form. Pull requests were not automatically tested. Deployments involved manual steps known to a small number of individuals that had never been formally documented. The gap between what the team knew collectively and what the system required of anyone executing a deployment was wide enough to be an operational risk.

The broader challenge was that this was a domain-heavy codebase in a specialized field. Off-the-shelf modernization approaches do not account for platforms where understanding the code means understanding canine genetics well enough to know whether a refactoring has preserved the semantic correctness of the domain logic — not just that the tests pass, but that the tests are testing the right thing.

The approach

Protabyte approached the engagement in phases, applying AI-enabled engineering practices as a deliberate accelerant at each stage rather than as an afterthought.

The first phase was AI-accelerated codebase assessment. Using AI tooling to systematically traverse a large, domain-heavy codebase, the team mapped where genomics processing logic was concentrated, identified the API endpoints carrying the heaviest responsibility overlap, and surfaced the dependency chains most likely to affect result accuracy if changed. This phase compressed what would have taken several weeks of manual archaeology into a focused assessment cycle. The AI analysis produced evidence; the engineering judgment required to interpret that evidence in the context of a DNA testing platform was human.

The second phase focused on test coverage for the highest-risk processing paths. AI-assisted test generation was used to produce initial test scaffolding for the breed probability, health marker scoring, and allele interpretation routines. The scaffolding was reviewed and enriched by engineers who understood the domain logic — validating expected outputs against known genetic data, adding edge cases the AI-generated scaffolding had not anticipated, and ensuring the tests were actually testing genomics correctness rather than just exercising code paths. The output was a behavioral test suite that could validate the domain logic in isolation, before any refactoring touched it.

With test coverage in place on the highest-risk paths, the third phase addressed API refactoring and concern separation. Genomics domain logic was extracted from serializer and view-layer handlers into explicit service boundaries. The API surface was refactored to DRF conventions with single-responsibility endpoints. Validation, transformation, domain processing, and persistence were separated into explicit layers — improving both clarity and independent testability. Each refactoring step was validated against the test suite established in the previous phase.

The fourth phase addressed the CI/CD and deployment foundation. Automated test execution was introduced on every pull request. Linting and type-checking were added to the pipeline. Deployment procedures that had existed only as tribal knowledge were documented in runbooks, de-personalizing the process so that any qualified team member could execute it.

The final phase used AI tooling to accelerate documentation of undocumented domain logic. Processing functions that had never had documentation were analyzed with AI assistance to produce initial descriptions, which engineers then reviewed, corrected against domain expertise, and refined into accurate technical documentation. Architecture decision records were produced for the key design choices made during the engagement.