Scout the match. Understand the robot. Build the strategy.
Neptune is a complete FIRST Robotics Competition scouting platform for pre-scouting, pit scouting, synchronized live match scouting, team and robot intelligence, analytics, strategy, event control, TBA data, and multi-organization operation. Run it as a hosted account, on your own cloud server, or on a portable local server at an event.
Neptune connects the work your team does before an event, in the pits, in the stands, at the strategy table, and during live match operations. Every module is designed to contribute to the same event data set.
Scouts receive an assigned robot and record configured game actions during the match. Neptune tracks success and failure, scoring value, match time, alliance and robot context while the match-control workflow keeps scouting devices synchronized.
Control event scouting from one place. Prepare the next match, monitor scout readiness, start and pause the match state, watch incoming data, and identify missing coverage before it becomes a problem.
Build robot profiles with capabilities, mechanical information, drive notes, strategy observations and photos. Use phone cameras in the pit or upload images from another device.
Research teams before the event and store performance history, robot architecture, scoring capability, drive characteristics, endgame notes and other season context by game and year.
Use collected scouting data to compare teams, review scoring and action trends, inspect robot records and move from individual observations to a larger picture of event performance.
Bring scouting and robot intelligence into match planning. Review your alliance, opponents, likely roles, weaknesses, strengths and the data your strategy group needs before talking to the drive team.
Define the game Neptune scouts. Configure actions, points, field locations, periods and interface behavior, then store that configuration as game data used by events and scouting pages.
Create events early, attach the correct game, choose the current event, manage teams and later link a manual event to official event data without throwing away pre-scouting or pit work.
Find season events, import team rosters and schedules, or link official TBA data to an event that your team created before the official schedule was available.
Neptune supports separate organizations with organization-scoped data. Controlled sharing can make selected scouting information available to partner organizations without changing who owns the original records.
Strategy, Admin, and Owner users can explore their organization's scoped scouting data with read-only SQL, aggregates, joins, grouping and analysis while platform-level administration remains isolated.
Neptune includes web-app assets for a phone- and tablet-friendly experience. It can be placed on home screens and used as the team's event-day scouting interface without requiring a native app store build.
Neptune is organized around the way an FRC scouting group actually works: prepare the game and event, understand the robots, collect match actions, then turn those observations into decisions.
Define actions, point values, periods and the scouting interface.
Import from TBA or create it manually before official data appears.
Complete pre-scouting and pit profiles before qualification scouting fills in the rest.
Assign robots, synchronize scouts and capture actions as the match happens.
Analyze teams, prepare match strategy and evaluate alliance possibilities.
The match-control side of Neptune manages the live match state while scouts focus on the robot in front of them.
Pre-scouting, pit information and match actions are different kinds of observations, but Neptune brings them together around the same teams, robots, games and events.
Teams do not all have the same IT resources or event connectivity. Neptune can be used as a hosted account or installed on infrastructure your team controls.
Use this Neptune installation without managing Apache, PHP, MySQL, certificates, updates or server hardware.
Run a private Neptune instance on an always-online Linux server with your own hostname, HTTPS certificate and database.
Put Neptune on a laptop, mini PC or Raspberry Pi-class Linux machine, connect it to a local router or access point, and bring the server to the competition.
Run Neptune on a developer workstation for testing, Game Builder work, themes, PHP changes and database development before pushing changes to the team server.
A portable installation uses the same web application and database, but the server sits on your local event network instead of depending on a remote web host for every request.
If you want to use the hosted platform, you do not need to install a server. Start with an organization, then configure the team and event.
Create the Neptune organization that will own your team's users, events and scouting records.
The organization owner manages setup, administrative tools, users and organization-level configuration.
Set up the team identity, then create the accounts and roles needed by scouts, strategists and administrators.
Use the appropriate game configuration so Neptune knows which actions and scoring behaviors scouts should record.
Use TBA when official data is available, or create the event early and link it later without losing your pre-scouting and pit work.
Complete pre-scouting, collect pit data, confirm the team roster and make sure your scout devices can sign in.
Coordinate the crew, start match sessions and monitor whether scouting data is being collected across the event.
Use the accumulated event data for team analysis, robot intelligence, match preparation and alliance evaluation.
Neptune is a PHP/MySQL web application. A self-hosted deployment keeps the public application under the web root and places sensitive configuration outside the public directory.
# 1) Install a typical web stack sudo apt update sudo apt install apache2 mysql-server php php-mysql \ php-curl php-mbstring php-xml php-zip php-gd unzip git # 2) Clone Neptune git clone https://github.com/blarkin13/neptune-frc-scouting neptune cd neptune # 3) Public/private layout /var/www/.../public_html/Neptune/ ../neptune_secure/ sql/ scripts/ # 4) Create the database and import Neptune's schema mysql -u root -p CREATE DATABASE Neptune; EXIT; mysql -u root -p Neptune < sql/neptune_schema.sql # 5) Create the private config cp neptune_secure/config.example.php \ neptune_secure/config.php # Add DB credentials + TBA configuration to config.php # 6) Point Apache at the public Neptune application # Keep neptune_secure OUTSIDE the public web root. # 7) Create the first organization + owner /Neptune/register.php # Neptune has no admin/install.php browser installer. # After sign-in, run System Check and review Maintenance Console.
Keep the source in GitHub, make application changes in a development environment, and deploy tested updates to the production or portable server.
The application needs a web server, PHP and MySQL. AWS is one way to provide that stack, but another Linux VPS or suitable team-owned server can run the same application.
Neptune separates public application files from protected configuration, scopes operational data by organization, and uses common web security controls throughout the application.
User passwords are verified using PHP's password-hashing APIs rather than stored as readable passwords.
Database and API configuration can remain outside the public web root instead of being directly served by Apache.
Operational application queries use prepared statements rather than building unsafe SQL from browser input.
Administrative, scouting and organization functions are separated according to the user's authenticated role.
Operational data is associated with organizations so one organization's application view does not become another team's database view.
Database exploration can remain read-only and organization-scoped rather than exposing unrestricted server administration.
Register your team and start configuring Neptune now, or use the GitHub project to deploy a private cloud, portable event or local development instance.