GTX Next & Services — R&D Tax Credit Platform

Page 2: Python ETL Logic & Qualification Engine

The processing engine applies qualifying tax logic to raw ledger data to isolate eligible hours using vectorized matching.

1. The IRS Four-Part Test Mapping Engine

import re
import pandas as pd

def apply_irs_four_part_test(time_logs_df: pd.DataFrame, task_column: str) -> pd.DataFrame:
    """Evaluates time logs for Section 41 R&D credit eligibility using string matching."""
    
    PERMITTED_PURPOSE_PATTERN = re.compile(
        r"\b(architecture|prototype|algorithm|refactor|machine\s*learning|ai|"
        r"backend|compiler|database\s*schema|cryptography|api\s*design|"
        r"proof\s*of\s*concept|poc|testing\s*automation|ci/cd|infrastructure|"
        r"neural\s*network)\b", re.IGNORECASE
    )

    STATUTORY_EXCLUSIONS_PATTERN = re.compile(
        r"\b(bug\s*fix|maintenance|marketing|sales|website\s*style|"
        r"customer\s*support|wordpress|seo|content|social\s*media|internal\s*it|"
        r"data\s*entry|administrative|meeting|overhead)\b", re.IGNORECASE
    )

    descriptions = time_logs_df[task_column].fillna("").astype(str)
    is_permitted = descriptions.str.contains(PERMITTED_PURPOSE_PATTERN, regex=True)
    is_excluded = descriptions.str.contains(STATUTORY_EXCLUSIONS_PATTERN, regex=True)

    time_logs_df["is_qre_eligible"] = is_permitted & ~is_excluded
    return time_logs_df

2. Substantially All (80/20) Allocation Engine

def calculate_w2_qre_allocations(processed_logs_df: pd.DataFrame, payroll_df: pd.DataFrame) -> pd.DataFrame:
    """Applies the IRS 'Substantially All' (80/20) rule to allocate W-2 wages into QREs."""
    
    processed_logs_df["hours_spent"] = processed_logs_df["hours_spent"].astype(float).fillna(0.0)
    
    hourly_summary = processed_logs_df.groupby("employee_id").agg(
        total_hours=("hours_spent", "sum"),
        qualified_hours=("hours_spent", lambda x: x[processed_logs_df.loc[x.index, "is_qre_eligible"]].sum())
    ).reset_index()

    hourly_summary["rd_time_percentage"] = (hourly_summary["qualified_hours"] / hourly_summary["total_hours"]).fillna(0.0)

    def apply_irs_statutory_thresholds(pct: float) -> float:
        if pct >= 0.80:
            return 1.00
        if pct < 0.20:
            return 0.00
        return pct

    hourly_summary["statutory_allocation_percentage"] = hourly_summary["rd_time_percentage"].apply(apply_irs_statutory_thresholds)
    
    allocated_wages = pd.merge(payroll_df, hourly_summary, on="employee_id", how="inner")
    return allocated_wages

Page 3: Star Schema Architecture & Storage Layer

The analytics layer uses a Star Schema design with a central Fact Table recording individual time logs, linked to surrounding dimension tables.

Star Schema Table Specifications

Page 4: Strategy, Market Viability & Pricing Models

Section 174 expense capitalization rules and Form 6765 changes have increased compliance demands. The platform builds a long-term asset by combining SaaS subscriptions, CPA referral revenue, and audit retainers.

Pricing Strategy Evaluation

3-Year Multi-Year Client Lifetime Value (LTV)

Page 5: IRC § 7216 Compliance & CPA Agreements

Under IRC § 7216 and Treas. Reg. § 301.7216-3, providers processing tax information must obtain explicit standalone written consent before utilizing data for non-preparation purposes.

Statistical Compilation & 10-Entity Minimum Rule

Treas. Reg. § 301.7216-2(h) allows commercializing aggregated benchmarks if data is converted into statistical compilations. Every cohort or exported index must aggregate a minimum of 10 separate taxpayer entities to prevent individual re-identification.

Key Contractual Pillars (CPA Network Agreement)

• Liability Partitioning: Separates the data software platform from professional tax services provided by CPA partners.
• Database Retention: Platform provider retains ownership of system usage metadata and user profiles.
• Circular 230 / AICPA Compliance: Payments are structured as software licensing fees rather than fee-splitting arrangements.

Page 6: Tax Software Integration Architecture

Integrating R&D engines into CCH Axcess, UltraTax CS, and Drake Tax requires distinct approaches due to system architecture differences.

Integration Matrix

Page 7: Lead Generation Schema & Prospecting Engine

To identify target non-claimant companies, the platform ingests external signals (LinkedIn, GitHub GraphQL, OpenCorporates) to estimate QREs and lost tax credits.

Prospect Database PostgreSQL Schema

CREATE TABLE rd_prospect_database (
    prospect_id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    company_name VARCHAR(255) NOT NULL,
    ein_hash VARCHAR(64) UNIQUE, -- Anonymized identifier
    naics_code VARCHAR(6) NOT NULL,
    estimated_annual_revenue NUMERIC(15, 2),
    us_headcount INT,
    engineering_headcount INT,
    est_qre_wages NUMERIC(15, 2),
    est_unclaimed_fed_credit NUMERIC(15, 2), -- ~10% ASC Baseline
    total_3yr_lost_opportunity NUMERIC(15, 2),
    assigned_cpa_partner_id UUID,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Opportunity Estimator Script

def calculate_lost_rd_opportunity(
    eng_headcount: int,
    avg_eng_salary: float = 135000,
    cloud_dev_spend: float = 50000
) -> dict:
    """Estimates 1-year and 3-year unclaimed Section 41 credits."""
    qre_wages = (eng_headcount * avg_eng_salary) * 0.80
    total_qre = qre_wages + cloud_dev_spend
    
    fed_credit_annual = total_qre * 0.10
    state_credit_annual = total_qre * 0.05
    total_annual_lost = fed_credit_annual + state_credit_annual
    
    return {
        "annual_qre": round(total_qre, 2),
        "total_annual_lost": round(total_annual_lost, 2),
        "three_year_lost_opportunity": round(total_annual_lost * 3.0, 2)
    }