Developers

How NIL33 works under the hood.

Deterministic scoring. Rust-powered engine. Cryptographic receipts. 50-state compliance rulesets. This page is for engineers, auditors, and technical evaluators.

Architecture

System overview.

nil33-architecture.txt

┌─────────────────────────────────────────────────┐
│                   NIL33 Stack                   │
├─────────────────────────────────────────────────┤
│                                                 │
│  ┌─────────────┐   ┌────────────┐   ┌────────┐ │
│  │  Next.js UI  │──▶│  API Layer │──▶│  Rust  │ │
│  │  (React 19)  │   │ (REST/JSON)│   │ Engine │ │
│  └─────────────┘   └────────────┘   └────────┘ │
│                                         │       │
│                          ┌──────────────┤       │
│                          ▼              ▼       │
│                    ┌──────────┐  ┌───────────┐  │
│                    │ Rulesets │  │  Receipts  │  │
│                    │ (50 + 10)│  │ (Ed25519)  │  │
│                    └──────────┘  └───────────┘  │
│                                                 │
└─────────────────────────────────────────────────┘

Frontend

Next.js 16, React 19, Tailwind 4. Static export for edge deployment. No client-side data persistence.

API Layer

REST endpoints for scoring, compliance checking, and receipt generation. JSON in, JSON out. Stateless.

Rust Engine

Core scoring and compliance logic written in Rust for deterministic, auditable computation. No floating-point ambiguity.

Scoring model

The 33 factors.

Every athlete is scored across 33 weighted factors in four categories. Each factor has a defined input type, normalization method, and weight. The composite score is the weighted sum, normalized to 0–99.

Social Reach

Weight: 25%

1.Instagram followers
2.Instagram engagement rate
3.TikTok followers
4.TikTok engagement rate
5.Twitter/X followers
6.YouTube subscribers
7.Content posting frequency
8.Platform diversity score
9.Audience authenticity index

Athletic Performance

Weight: 30%

1.Position-specific stats (passing yards, tackles, etc.)
2.Conference tier
3.Team win-loss record
4.Individual awards & honors
5.Draft stock / mock draft position
6.Years of eligibility remaining
7.Games started
8.Position scarcity premium

Market Demand

Weight: 25%

1.Media mentions (last 90 days)
2.Regional market size
3.Sport premium (football vs. other)
4.NIL market maturity (by state)
5.Competing offers / market saturation
6.Seasonal demand factor
7.Rivalry / rivalry game premium
8.Postseason exposure potential

Brand Alignment

Weight: 20%

1.Audience demographic quality
2.Brand safety score
3.Narrative / story value
4.Community involvement
5.Content quality index
6.Uniqueness / differentiation
7.Long-term brand potential
8.Cross-sport appeal

Engine design

Deterministic scoring.

NIL33 produces deterministic scores: the same inputs always produce the same output. This is a design requirement for auditability.

Why Rust?

▸No garbage collection pauses — predictable execution
▸Integer arithmetic for scoring — no floating-point drift
▸Memory safety without runtime overhead
▸Compiles to WASM for browser-side validation
▸Sub-millisecond score generation

score_deal.rs

// Input: AthleteProfile + DealProposal

// Output: ScoredDeal (deterministic)

fn score_deal(

profile: &AthleteProfile,

proposal: &DealProposal,

rules: &ComplianceRuleset,

) -> ScoredDeal {

// 33-factor weighted composite

// Integer arithmetic only

// Compliance check included

// Receipt generated on success

}

Regulation

Compliance rulesets.

NIL33 maintains structured compliance rulesets for all 50 states and 10+ conference-specific rule sets. Each ruleset is versioned, timestamped, and auditable.

State rulesets

10+

Conference rulesets

v3.2

Current ruleset version

state-law-georgia.json

StateLaw {
  state:          "Georgia"
  effective_date: "2024-07-01"
  version:        "3.2.1"
  
  requires_disclosure:       true
  max_contract_duration:     12      // months
  institutional_involvement: "prohibited"
  agent_registration:        "required"
  tax_reporting_threshold:   600     // USD
  
  restrictions: [
    "No pay-for-play (performance bonuses prohibited)",
    "No institutional NIL deals (school cannot be party)",
    "Agent must be registered with state"
  ]
}

Audit trail

Cryptographic deal receipts.

Every scored deal produces a receipt signed with Ed25519. Receipts are tamper-evident: any modification invalidates the signature.

Receipt Contents

▸Receipt ID (unique, sequential)
▸Athlete profile hash (SHA-256)
▸Deal proposal details
▸Composite score + sub-scores
▸Valuation band (low–high)
▸Compliance check results
▸Timestamp (ISO 8601, UTC)
▸Ruleset version used
▸Ed25519 signature

verify.rs

// Verify any receipt with the public key

let valid = verify_receipt(

receipt: &Receipt,

pub_key: &PublicKey,

) -> bool;

// Returns true if receipt is untampered

// Returns false if any field was modified

Why Ed25519?

• 128-bit security level
• Deterministic signatures (no random nonce)
• Small keys (32 bytes public, 64 bytes private)
• Fast verification (~71,000 ops/sec)
• Widely audited (used by SSH, Signal, Tor)

Data ingestion

Data pipeline.

NIL33 ingests data from multiple sources to build athlete profiles. All data flows through normalization before reaching the scoring engine.

data-pipeline.txt

Social APIs          Athletic Data         Market Signals
(Instagram,          (Stats providers,     (News APIs,
 TikTok, X,           conference data,      Google Trends,
 YouTube)             awards databases)     regional data)
     │                      │                     │
     ▼                      ▼                     ▼
┌──────────────────────────────────────────────────────┐
│              Normalization Layer                      │
│  • Rate limiting   • Deduplication   • Validation    │
│  • Unit conversion • Null handling   • Freshness     │
└──────────────────────────────────────────────────────┘
                         │
                         ▼
              ┌─────────────────────┐
              │   Athlete Profile    │
              │  (33 normalized      │
              │   factor inputs)     │
              └─────────────────────┘
                         │
                         ▼
              ┌─────────────────────┐
              │    Rust Scoring      │
              │    Engine            │
              │  • Weighted sum      │
              │  • Integer math      │
              │  • Deterministic     │
              └─────────────────────┘
                         │
                         ▼
              ┌─────────────────────┐
              │   Scored Deal +      │
              │   Signed Receipt     │
              └─────────────────────┘

Integration

API reference (preview).

Enterprise customers get REST API access for integration with internal tools, CRMs, and deal management systems.

POST

/api/v1/score

Score an athlete and return composite + sub-scores + valuation band

POST

/api/v1/compliance

Check a deal proposal against state, conference, and NCAA rules

POST

/api/v1/receipt

Generate a signed receipt for a scored deal

GET

/api/v1/receipts/:id

Retrieve and verify an existing receipt

GET

/api/v1/rulesets/:state

Get the current compliance ruleset for a state

Built in the open.

NIL33's scoring engine and compliance rulesets are designed for auditability. We believe the best way to earn trust is transparency.

GitHub →Contact Engineering