How to Enter Your First SignalNet Competition

Ready to put your quant skills to the test? This guide walks you through submitting your first signal to SignalNet — from signup to your first stake.

Before You Start

You'll need:

• A crypto wallet (MetaMask, Coinbase Wallet, or any EVM wallet)
• Python 3.9+ (or any language that can output CSV)
• About 30 minutes for your first submission

Step 1: Create Your Account

Head to signalnet-app.vercel.app and click Launch App.

You'll sign up with your email and connect your wallet. SignalNet uses hybrid auth — your email is for notifications and account recovery, your wallet is for staking and payouts.

Step 2: Get Your API Key

Go to Settings → API Keys and generate a new key. You'll need this for the Python SDK.

pip install signalnet-sdk

Step 3: Download the Features

from signalnet import Tournament

t = Tournament(api_key="sn_your_api_key_here")

# What round are we on?
round_info = t.current_round()
print(f"Round #{round_info.id}")
print(f"Deadline: {round_info.close_time}")
print(f"Stocks: {round_info.universe_size}")

# Download features
features = t.get_features()
print(features.head())

You'll get a DataFrame with ~503 rows (stocks) and ~98 columns (encrypted features). The features are normalized to [0, 1] — you don't know what they represent, and that's by design.

Step 4: Build Your Model

Here's a simple starter model. It won't win any competitions, but it's a valid submission:

import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingRegressor

# Load historical data for training
historical = t.get_features(round_id=round_info.id - 4)
historical_targets = t.get_targets(round_id=round_info.id - 4)

# Train a simple model
model = GradientBoostingRegressor(
    n_estimators=200,
    max_depth=4,
    learning_rate=0.05,
    subsample=0.8,
    random_state=42
)
model.fit(historical.values, historical_targets.values)

# Predict on current features
raw_predictions = model.predict(features.values)

# Normalize to [0, 1]
predictions = pd.Series(raw_predictions, index=features.index)
predictions = (predictions.rank() - 1) / (len(predictions) - 1)

Pro Tips for Your Model

• Use rank-based normalization (as above) — it's more robust than min-max
• Don't overfit to one round — use multiple historical rounds for training
• Try different algorithms — XGBoost, LightGBM, neural nets, even simple linear models
• Feature selection matters — some features are noise. Try removing low-importance ones
• Ensemble your own models — combine 3-5 approaches for stability

Step 5: Start with a Practice Round

Before staking real tokens, validate your pipeline with a practice round:

# Submit to practice (instant feedback, no staking)
practice_result = t.practice.submit(
    dataset_id='2024-q3',
    predictions=predictions
)

print(f"IC: {practice_result.ic:.4f}")
print(f"Percentile: Top {practice_result.percentile}%")

If your IC is positive, you're on the right track. If it's above 0.02, you're doing well.

Step 6: Submit for Real

# Create submission DataFrame
submission = pd.DataFrame({
    'ticker': features.index,
    'prediction': predictions.values
})

# Submit with stake
result = t.submit(
    predictions=submission,
    stake=100  # Start small — 100 SIGNAL minimum
)

print(f"✅ Submitted!")
print(f"Signal hash: {result.signal_hash}")
print(f"Staked: {result.stake} SIGNAL")
print(f"Round closes: {round_info.close_time}")

Start with the minimum stake (100 SIGNAL). You can always increase it once you're confident in your model.

Step 7: Track Your Progress

After submitting, you'll see daily provisional scores on the Performance page.

# Check provisional scores
provisional = t.submissions.provisional(round_id=round_info.id)
for day in provisional:
    print(f"Day {day.trading_day}: IC={day.ic:.4f}")

These update after each trading day. They're not final — the full 20-day resolution can differ significantly from early provisional scores.

Step 8: Wait and Learn

Your round resolves after 20 trading days. During this time:

• Enter the next round — rounds overlap, so there's always a new one
• Iterate on your model — try new features, algorithms, or ensembles
• Watch the leaderboard — see how other contributors are performing
• Read the forums — learn from the community (without revealing your model!)

Common Mistakes to Avoid

❌ Overfitting to Practice Rounds

Practice rounds use historical data. A model that scores 0.05 IC on practice data might score 0.01 on live data. Use practice for pipeline validation, not model optimization.

❌ Staking Too Much Too Early

Start with 100 SIGNAL. Even experienced quants have losing rounds. Increase your stake as you build a track record over 5-10 rounds.

❌ Copying Popular Strategies

IC rewards accuracy, but TC and MMC reward uniqueness. If everyone uses the same XGBoost model with default parameters, the TC for that approach drops to zero. Find your own edge.

❌ Ignoring Feature Importance

Not all 98 features are useful. Some are noise. A model trained on all features might perform worse than one trained on a carefully selected subset.

❌ Submitting at the Last Minute

The submission deadline is firm. Build your pipeline to submit early, then optionally update before the deadline if your model improves.

What Good Looks Like

After a few rounds, here's what a solid contributor profile looks like:

Metric	Beginner	Solid	Elite
Avg IC	0.005	0.020	0.035+
Win Rate	52%	58%	65%+
TC	~0	0.01	0.02+
Consistency	High variance	Moderate	Low variance

You don't need to be elite to earn. A consistent IC of 0.015 with moderate stake earns meaningful rewards over time.

Ready?

Create your account → Read the full docs → Join the community →

Welcome to SignalNet. May your signals be strong and your correlations be low. 📡