Delta
Click to visitA market
built to teach.
A live stock-market simulation for classrooms and competitions. Instructors create the companies and move the market. Participants decide what to do next.
Explore the projectYou learn
when the choice
is yours.
A price chart shows what happened. An instructor-controlled market gives a classroom a reason to ask why.
Financial ideas become concrete when a learner has to make a decision. A limited balance introduces opportunity cost. A falling price reveals exposure. A news item asks whether to act now or wait.
Delta makes those conditions teachable. An instructor creates stocks, sets opening prices, and prepares developments with associated price changes. Participants start with $3,000 in virtual cash, follow the news, and buy, sell, or hold.
The purpose is to give people room to reason about risk and information. Trade records and changing portfolios make decisions available for discussion after the moment has passed. Activity is visible; measured learning outcomes are still a future step.
One piece
of news.
A development joins a story to a set of price changes. The instructor shapes the situation. The participant owns the decision.
New rail link.
Lower shipping costs.
Instructor’s desk · illustrative scenarioThe instructor prepares a development and sets Atlas Logistics to move from $100 to $120 when it is published.
Opening price · no change yet
- Illustrative holding
- 10 shares
- Holding value
- $1,000
- Cash, unchanged
- $2,000
- Total assets
- $3,000
An interactive explanation, not a live Delta session. All company names and values in this example are synthetic. Publishing changes the price; it does not place a trade.
- Prepare
Create stocks and draft the news.
- Open
Let participants enter the market.
- Publish
Release a development and its prices.
- Decide
Buy, sell, or keep a position.
- Discuss
Use the records to revisit the choice.
One market.
Three distances.
The participant.
Explore companies and price histories, read published developments, and place orders. Cash, holdings, total assets, and return stay together. A trade history records execution price, quantity, and time, so decisions can be revisited.
The instructor.
Create stocks, prepare developments, and open or close trading. Review participants, trades, holdings, and activity through the administrator portal. Drafts stay out of participant-facing server queries, keeping future market information private.
The shared display.
Remove navigation and order controls. Enlarge the quotes, add a ticker, and show the leading participants. The main board holds up to ten stocks; the leaderboard shows six participants ranked by cash plus current holdings value.
Loud at
the door.
Clear at
the desk.
The public page can feel like a trading floor. The order ticket needs to explain a decision.
A terminal with a purpose.
Delta’s landing page uses a continuous quote board, dot-matrix headings, thin rules, and docked panels. The headline belongs to a row of the board. Opaque panels keep text readable over the changing background, and only a few quotes change on each tick.
Inside the application, the same identity becomes quieter. Stable surfaces replace scanlines and bloom around working controls. Doto gives headings their quote-board character; Commit Mono handles text and data. Tabular numerals keep prices aligned.
#050A07Phosphor
#31D96AReading text
#A8E6BF
Show the consequence before the action.
The order ticket connects quantity to order value and remaining cash. It states how many shares are affordable or available. Invalid actions are disabled with a reason, and the final button repeats the action and share count. Selling is unavailable without a holding.
Let an empty chart explain itself.
A chart failure needs a persistent error and retry action. A toast that disappears leaves an unexplained blank. Missing values remain distinct from zero, and missing opening prices never become a false 0% change.
Make the details consistent.
Shared panels, buttons, fields, readouts, formatters, and a single sidebar keep the two portals aligned. Visible focus, associated labels, and accessible password controls improve everyday navigation. Deletion dialogs name the consequence, trap focus, support Escape, and restore focus afterward.
Give movement a stopping point.
The mechanism demonstration plays once and offers replay. Reduced-motion handling shows its settled state. Trade success has both visual and audio feedback. The public page can attract attention without asking the working interface to compete with it.
Clarity is
part of
fairness.
A participant should understand what an order costs. A draft should remain private. A closed market should reject trades on the server.
Fairness depends on both the explanation and the rules behind it. A polished percentage is still misleading if its starting balance is wrong.
Access is part of that purpose too. Delta’s published Pay What You Can model includes free competitions, supported in part by grants. Its stated donations support orphanages and laptops for students.
Behind
the change.
- Interface
- React 19 · Vite · React Router
Zustand · Axios · Tailwind CSS · Recharts - Server & records
- Node.js · Express 5 · MongoDB · Mongoose
Socket.IO · JWT cookies · bcryptjs - Motion & graphics
- GSAP · ScrollTrigger
OGL · GLSL
From a sentence
to a shared price.
A development stores its content, publication state, and optional stock-price changes. On publication, the server reads those changes, updates each affected stock, and adds a historical price record. Socket.IO broadcasts stockPriceUpdated, and clients update their shared stock state. The development’s publication state is then updated.
Durable records live on the server. Zustand separates authentication, market, trading, administrator, and socket state. HTTP handles ordinary reads and writes; sockets carry price and market-status updates.
The boundaries matter: development reads still use HTTP. Multi-stock publication processes changes sequentially and can partly succeed. It does not provide an atomic transaction across the whole event.
The server
sets the terms.
A trade request checks market status, reads the stock’s server-side price, validates a positive amount, and checks cash or holdings. A successful request records the trade and updates the account. A client cannot choose its execution price, and market closure is enforced beyond the interface.
Protected HTTP routes check administrator authorization. Participant development queries require posted: true, including detail requests. Hiding a draft in the interface alone would leave its information exposed.
Live where
it matters.
The selected quote is derived from the current stock list, so socket changes reach it without an extra copy of state. History and company information load when the selected instrument changes, rather than on every price update. The parent owns the chart request; the chart owns its retry control.
The event display refreshes participant records every 20 seconds. Price events alone miss trades that change holdings without changing a price. Sorting a copied stock array also prevents the display from changing the order in other views. Read-only Mongoose queries commonly use .lean().
Spend rendering
work carefully.
The terminal shader runs through OGL at half resolution with a 30 FPS cap. Intersection observation skips work offscreen; resize observation keeps the canvas fitted. Smoothed pointer coordinates update an existing uniform array, and passive touch listeners preserve scrolling.
Cleanup releases animation frames, observers, listeners, and the WebGL context. Reduced motion freezes shader time and disables hero pointer and entrance effects. These are specific rendering choices, with no measured performance gain claimed.
A product,
over time.
From a working trade to a shared event, then a more consistent product. Dates follow the development history, rather than a claimed launch timeline.
Make a trade possible.
React and Node established the foundation. Authentication, roles, stocks, balances, portfolios, developments, and price history followed. A finite balance and a recorded trade gave the simulation its basic rules.
Build the whole event.
Route-based screens replaced component-switched content. Dashboards, analytics, help, and administrator controls expanded the product. Socket.IO added price and market-status updates. A dedicated display let the room follow along. Later that month, developments gained their own stock-price changes.
Make the numbers agree.
Starting-cash changes exposed a mismatch between $1,000 and $3,000 return baselines. A shared frontend constant brought the calculation into line with the backend’s $3,000 default. The public landing page then added an explanation of the product, pricing, and access.
Give the product one language.
A continuous quote wall replaced the earlier sequence of marketing sections. A staged demonstration explained the central mechanism. The terminal shader followed, with rendering and interaction refinements. A 47-file standardization brought shared controls, clearer feedback, calculation fixes, and draft protection into the application.
Say it plainly.
“Disbursement” became “Where the money goes.” “Watch the mechanism” became “See how it works.” The terminal identity stayed, while the wording became easier to understand.
Used in
the room.
600+ participants
10+ competitions
$16M+ in simulated volume
Project-reported activity as of March 2026. Simulated volume is virtual trading activity. These figures describe participation, not measured learning outcomes.
Delta also reports more than $1,000 donated toward orphanages and laptops for students. The published donation total has no separate reporting date.
Make the rules
more rigorous.
Make the lesson
last longer.
The next step is stronger records and better reflection around each event.
These are proposed directions grounded in the current implementation, without delivery dates.
First, trust the record.
Trade records and account changes currently use separate writes. Atomic updates, concurrency controls, and idempotent submissions would make simultaneous orders and partial failures safer. Position accounting also needs weighted-average or lot-based cost basis: additional purchases currently replace the stored purchase price.
Then, strengthen the shared session.
Socket identity checks and server-owned broadcasts need to match the protection of HTTP routes. Reconnection needs a defined resynchronization process. Multi-stock publication needs clear failure and republishing rules.
Give each competition its own space.
The current data model uses a shared market. Competition-scoped records, invitations, configurable starting cash, round controls, resets, and archived results would make independent events easier to manage.
Connect decisions to their context.
Reusable scenarios could pair developments with learning objectives. A debrief timeline could connect news, trades, and portfolio changes, with optional explanations from participants. Before-and-after exercises and educator feedback could then test what people actually learn.
Measured mobile and low-bandwidth performance, fuller keyboard and screen-reader review, motion and audio controls, and operational monitoring would support a broader range of classrooms.