Nija

App Store Safety Explanation - NIJA Trading Platform

Document Version: 1.0
Last Updated: February 2, 2026
For: Apple App Review / Google Play Review
Purpose: Demonstrate safety of NIJA’s independent trading model

CRITICAL SAFETY GUARANTEE
Tier-based capital protection is enforced in all environments and cannot be bypassed.

Executive Summary

NIJA is a safe, transparent, and compliant algorithmic trading platform that uses an independent trading model. Each user account makes its own trading decisions using the same algorithm, with position sizes calculated proportionally to their account balance.

Key Safety Points:

Table of Contents

  1. How NIJA’s Independent Trading Model Works
  2. Position Sizing Mathematics
  3. Live Trade Simulation Results
  4. Safety Mechanisms
  5. Why Results Differ Between Users
  6. Comparison to Prohibited Models
  7. Technical Implementation
  8. User Protection Features

How NIJA’s Independent Trading Model Works

The Core Principle

Each user account evaluates the market independently and makes its own trading decisions.

Think of NIJA like a GPS navigation app:

Similarly with NIJA:

What Happens When a Trade Signal Occurs

Platform Account (Reference):

  1. Algorithm analyzes market data every ~2.5 minutes
  2. Detects a trading opportunity (e.g., RSI oversold + trend confirmation)
  3. Calculates position size: $200 for a $10,000 account (2% risk)
  4. Executes trade on platform’s Coinbase account

User Accounts (Independent):

  1. Same algorithm runs on each user’s account independently
  2. Each account analyzes the SAME market conditions
  3. Each account INDEPENDENTLY detects the same opportunity
  4. Position size is calculated based on USER’s balance:
    • User with $100 balance → $2 position (2% risk)
    • User with $1,000 balance → $20 position (2% risk)
    • User with $25,000 balance → $500 position (2% risk)
  5. Each account executes its own trade on its own exchange account

Important: No “signal distribution” occurs. Each account reaches the same conclusion independently because they’re all running the same algorithm on the same market data.

Position Sizing Mathematics

The Formula

Position sizing uses a simple, transparent formula:

user_position_size = platform_position_size × (user_balance ÷ platform_balance)

This is called proportional scaling and ensures:

Example Calculations

Scenario: Platform account ($10,000 balance) takes a $200 BTC trade

User Balance Calculation Position Size Risk %
$50 $200 × ($50 ÷ $10,000) $1.00 2.0%
$100 $200 × ($100 ÷ $10,000) $2.00 2.0%
$500 $200 × ($500 ÷ $10,000) $10.00 2.0%
$1,000 $200 × ($1,000 ÷ $10,000) $20.00 2.0%
$5,000 $200 × ($5,000 ÷ $10,000) $100.00 2.0%
$25,000 $200 × ($25,000 ÷ $10,000) $500.00 2.0%

Notice: Every account maintains exactly 2.0% risk, scaled to their balance.

Exchange Minimum Enforcement

Exchanges have minimum trade sizes to prevent “dust” trades:

Impact on Small Accounts:

Using Kraken example:

This is a safety feature - it prevents unprofitable micro-trades that would be eaten by fees.

Fee-Aware Position Sizing

Every trade incurs fees that must be overcome for profitability:

Coinbase Fees (Limit Orders):

Example: $100 Trade

Smaller positions face higher fee pressure:

The percentage is the same, but smaller accounts have less room for slippage.

Live Trade Simulation Results

We’ve created a simulation tool (simulate_live_trade.py) that demonstrates the independent trading model.

Simulation Setup

Platform Account:

User Accounts: 10 accounts with balances from $50 to $50,000

Simulation Results

====================================================================================================
NIJA LIVE TRADE SIMULATION - INDEPENDENT TRADING MODEL
====================================================================================================

🎯 PLATFORM ACCOUNT (Reference):
   Balance: $10,000.00
   Trade Size: $200.00
   Risk %: 2.00%
   Exchange: COINBASE

📊 USER ACCOUNTS (10 accounts):
----------------------------------------------------------------------------------------------------
User ID           Balance       Tier   Trade Size    Effective    Scale %       Status
----------------------------------------------------------------------------------------------------
micro_1      $      50.00    STARTER $       1.00 $       0.00      0.50%    ❌ Invalid (too small)
micro_2      $     100.00      SAVER $       2.00 $       1.99      1.00%      ✅ Valid
small_1      $     250.00   INVESTOR $       5.00 $       4.98      2.50%      ✅ Valid
small_2      $     500.00   INVESTOR $      10.00 $       9.96      5.00%      ✅ Valid
medium_1     $   1,000.00     INCOME $      20.00 $      19.92     10.00%      ✅ Valid
medium_2     $   2,500.00     INCOME $      50.00 $      49.80     25.00%      ✅ Valid
large_1      $   5,000.00    LIVABLE $     100.00 $      99.60     50.00%      ✅ Valid
large_2      $  10,000.00    LIVABLE $     200.00 $     199.20    100.00%      ✅ Valid
whale_1      $  25,000.00     BALLER $     500.00 $     498.00    250.00%      ✅ Valid
whale_2      $  50,000.00     BALLER $   1,000.00 $     996.00    500.00%      ✅ Valid
----------------------------------------------------------------------------------------------------

📈 SIMULATION STATISTICS:
   Total Accounts: 10
   Valid Trades: 9 (90.0%)
   Invalid Trades: 1 (10.0%)
   Average Trade Size: $209.67
   Min Trade Size: $2.00
   Max Trade Size: $1,000.00
   Total Trading Volume: $1,887.00

Key Observations

  1. Position sizes scale proportionally - from $2 to $1,000 based on account balance
  2. One account blocked - $50 account’s $1 position is below $2 minimum (safety mechanism)
  3. 90% success rate - most accounts can trade safely
  4. 500x size variance - natural result of different account balances
  5. All approved accounts maintain 2% risk - proportional scaling works correctly

Running the Simulation Yourself

# Default simulation (10 users, Coinbase)
python simulate_live_trade.py

# Custom parameters
python simulate_live_trade.py --platform-balance 25000 --platform-trade-size 500 --num-users 20

# Different exchange (Kraken has higher minimums)
python simulate_live_trade.py --exchange kraken

# Detailed per-user breakdown
python simulate_live_trade.py --detailed

This simulation requires NO API credentials and uses NO real money - it’s purely mathematical demonstration.

Safety Mechanisms

1. Exchange Minimum Trade Sizes

Purpose: Prevent unprofitable micro-trades

Implementation:

Result: Accounts too small to profitably trade are blocked automatically.

2. Tier-Based Position Limits

Purpose: Prevent over-leveraging based on account maturity

Tier Structure:

Tier Capital Range Max Position Size Max Positions Risk Per Trade
STARTER $50 - $300 $10 2 3% - 5%
SAVER $300 - $1,000 $50 3 2.5% - 4%
INVESTOR $1,000 - $5,000 $150 4 2% - 3.5%
INCOME $5,000 - $10,000 $350 5 1.75% - 3%
LIVABLE $10,000 - $25,000 $750 6 1.5% - 2.5%
BALLER $25,000+ $1,500 8 1% - 2%

Result: Accounts are automatically assigned appropriate risk limits based on balance.

3. Fee-Aware Configuration

Purpose: Ensure trades can be profitable after fees

Implementation:

Example:

4. Stop Loss Enforcement

Purpose: Limit maximum loss per trade

Implementation:

Result: Maximum loss per trade is capped automatically.

5. Daily Loss Limits (Circuit Breaker)

Purpose: Prevent catastrophic drawdown in a single day

Implementation:

Example:

6. Maximum Drawdown Protection

Purpose: Protect accounts from extended losing streaks

Implementation:

Example:

7. Position Count Limits (Multi-Layer Enforcement)

Purpose: Prevent over-diversification and manage risk

Implementation:

Safety Guarantee:

Result: Accounts cannot exceed 8 positions, even in worst-case scenarios (crashes, network failures, database corruption). Multi-layer defense ensures cap is always enforced.

8. Independent Trade Validation

Purpose: Each account validates trades independently

Implementation:

Result: Trades approved for one account may be rejected for another (by design).

Why Results Differ Between Users

This is a critical transparency point for app reviewers. Results WILL differ between users, and this is expected, safe, and properly disclosed.

1. Timing Variations

Network Latency:

API Response Times:

Independent Scanning:

Market Conditions Change:

2. Account-Specific Factors

Balance Differences:

Existing Positions:

Available Capital:

Risk Settings:

3. Execution Differences

Fill Price Variations:

Slippage:

Order Book Depth:

4. Exchange Differences

Users can connect different exchanges:

Result: Same signal, different execution quality based on exchange choice.

Example: Why Two $1,000 Accounts Get Different Results

Account A:

Account B:

Same algorithm, same balance, different results due to:

  1. Timing (23-second difference)
  2. Existing positions (Account B had less free capital)
  3. Entry price ($20 difference due to market movement)
  4. Order type (Account A used limit, Account B used market)

This is EXPECTED and properly disclosed to users.

Comparison to Prohibited Models

❌ Copy Trading (Prohibited - NIJA Does NOT Do This)

How copy trading works:

  1. “Master” account executes a trade
  2. “Master” broadcasts trade signal to “follower” accounts
  3. “Follower” accounts copy the exact trade (mirrored)
  4. Synchronized execution across all accounts

Why it’s prohibited:

Example:

✅ Independent Trading (NIJA’s Model - Compliant)

How NIJA works:

  1. Each account runs the same algorithm independently
  2. Each account analyzes market data independently
  3. Each account makes its own trading decision
  4. Position size calculated based on account’s own balance
  5. Each account executes on its own schedule

Why it’s compliant:

Example:

Side-by-Side Comparison

Feature Copy Trading (Prohibited) NIJA (Compliant)
Trade signal source Master account Independent algorithm per account
Position sizing Fixed or master-based Proportional to account balance
Execution timing Synchronized Independent per account
Results between accounts Identical (if same balance) Naturally different
Account control Master controls followers Each account independent
Regulatory status Requires broker license Software tool
Disclosure Often not disclosed Fully transparent

Technical Implementation

System Architecture

┌─────────────────────────────────────────────────────────────┐
│                    NIJA Platform                            │
│  (Hosts the algorithm, provides infrastructure)             │
└─────────────────────────────────────────────────────────────┘
                            │
                            │ Algorithm
                            ▼
        ┌───────────────────────────────────────┐
        │                                       │
        ▼                                       ▼
┌──────────────┐                      ┌──────────────┐
│  User A      │                      │  User B      │
│  Account     │                      │  Account     │
│  ─────────   │                      │  ─────────   │
│  Balance:    │                      │  Balance:    │
│  $1,000      │                      │  $10,000     │
│              │                      │              │
│  Runs        │                      │  Runs        │
│  algorithm   │                      │  algorithm   │
│  every ~2.5  │                      │  every ~2.5  │
│  minutes     │                      │  minutes     │
│              │                      │              │
│  Calculates  │                      │  Calculates  │
│  own         │                      │  own         │
│  position    │                      │  position    │
│  size: $20   │                      │  size: $200  │
│              │                      │              │
│  Connects to │                      │  Connects to │
│  own         │                      │  own         │
│  exchange    │                      │  exchange    │
└──────┬───────┘                      └──────┬───────┘
       │                                     │
       │ API                                 │ API
       ▼                                     ▼
┌──────────────┐                      ┌──────────────┐
│  Coinbase    │                      │  Kraken      │
│  Account A   │                      │  Account B   │
│              │                      │              │
│  User A's    │                      │  User B's    │
│  funds       │                      │  funds       │
│  (never      │                      │  (never      │
│  leave this  │                      │  leave this  │
│  account)    │                      │  account)    │
└──────────────┘                      └──────────────┘

Data Flow

Market Data Analysis (per account):

  1. Account connects to exchange API
  2. Fetches latest candle data (OHLCV)
  3. Calculates technical indicators (RSI, EMA, MACD)
  4. Evaluates entry criteria
  5. If criteria met → calculate position size → execute trade
  6. If criteria not met → wait for next scan cycle

Position Sizing Calculation:

# Platform reference (for scaling ratio)
platform_balance = 10000.0
platform_trade_size = 200.0

# User account
user_balance = 1000.0

# Calculate scale factor
scale_factor = user_balance / platform_balance  # 0.1 (10%)

# Calculate user position size
user_trade_size = platform_trade_size * scale_factor  # $20

# Validate against minimums
exchange_minimum = 2.0  # Coinbase
if user_trade_size >= exchange_minimum:
    execute_trade(user_trade_size)
else:
    reject_trade("Position too small")

API Permissions

Users grant NIJA limited API permissions on their exchange:

Granted Permissions:

Never Granted:

User maintains full control - can revoke API access at any time via exchange settings.

Security Measures

API Key Storage:

Communication:

Monitoring:

User Protection Features

1. Comprehensive Risk Disclosures

First Launch Screen:

Strategy Activation Screen:

Daily Notifications:

2. Educational Resources

In-App FAQ:

Documentation:

3. User Controls

Anytime Access:

Monitoring:

4. Support & Safety Net

Customer Support:

Safety Alerts:

Demonstration for App Reviewers

How to Verify NIJA’s Safety

  1. Run the simulation: 
    python simulate_live_trade.py --detailed

    This demonstrates position sizing math without any API credentials.

  2. Review the calculations:
    • Verify proportional scaling (user_balance ÷ platform_balance)
    • Confirm exchange minimums are enforced
    • Check fee calculations
    • Validate tier limits
  3. Test with different scenarios: 
    # Small accounts
python simulate_live_trade.py --platform-balance 1000 --platform-trade-size 20
   
# Large accounts
python simulate_live_trade.py --platform-balance 100000 --platform-trade-size 2000
   
# Kraken exchange (higher minimums)
python simulate_live_trade.py --exchange kraken
  4. Examine the code:
    • position_sizer.py - Position sizing logic
    • tier_config.py - Tier limits and risk management
    • fee_aware_config.py - Fee calculations
    • simulate_live_trade.py - Full simulation

Questions App Reviewers May Ask

Q: Is this copy trading?
A: No. Each account runs the algorithm independently and makes its own decisions. Position sizes are calculated based on each account’s balance, not copied from another account.

Q: Why would results differ if everyone uses the same algorithm?
A: Timing variations (network latency, scan schedules), account-specific factors (balance, existing positions, risk settings), and execution differences (fill prices, slippage). This is expected and properly disclosed.

Q: How do you ensure smaller accounts are protected?
A: Multiple mechanisms: exchange minimum trade sizes ($2-$10), tier-based position limits, fee-aware sizing (rejects unprofitable trades), stop losses, daily loss limits, drawdown protection.

Q: Can users lose money?
A: Yes, and we’re very clear about this. Trading involves substantial risk. We display risk warnings throughout the app, require acknowledgment, and recommend starting small. Safety mechanisms limit losses, but profit is never guaranteed.

Q: Do you hold user funds?
A: Never. Users maintain funds on their own exchange account. NIJA only has trading permissions via API keys (no withdrawal access). Users can revoke access anytime.

Regulatory Compliance

What NIJA Is

What NIJA Is NOT

User Agreement

Users acknowledge:

Conclusion

NIJA is a safe, transparent, and compliant trading automation platform that:

  1. ✅ Uses an independent trading model (not copy trading)
  2. ✅ Implements proportional position sizing (smaller accounts = smaller risk)
  3. ✅ Provides mathematical transparency (simple, verifiable calculations)
  4. ✅ Includes multiple safety mechanisms (minimums, limits, circuit breakers)
  5. ✅ Ensures user maintains control (funds never leave their exchange)
  6. ✅ Clearly discloses risks (throughout the app experience)
  7. ✅ Educates users about why results differ

We’ve designed NIJA to meet the highest standards for financial applications while providing genuine value to users who want trading automation.

Contact for Review Questions

Developer Contact: support@nija.app
Documentation: This document + APPLE_APP_REVIEW_FINANCIAL_FUNCTIONALITY.md
Simulation Tool: simulate_live_trade.py (no credentials required)
Demo Account: Available upon request for App Review team testing

Document Version: 1.0
Last Updated: February 2, 2026
For: Apple App Review / Google Play Review