WINTERFELL

Ship Solana contracts in minutes, not months.

Full-stack engineerTeam projectwinterfell.dev

The Winterfell editor, writing a Solana smart contract in the browser.

01What it does

Winterfell is a browser IDE for Solana smart contracts. You describe a contract in plain words. A model writes a full Anchor project into the editor, and a terminal in the browser runs anchor build, test and deploy. It took first place at the Superteam India Hackathon.

I built the part that runs code we did not write: the Kubernetes build runners, the terminal that reaches them, and the pipeline that ships it all. I also built most of the frontend.

Role
Full-stack engineer. Build runners, terminal pipeline, CI/CD and frontend
Team
A small team. The code generator was led by a teammate
Stack
Next.js, Express on Bun, BullMQ, Redis, Postgres and Kubernetes
Status
Live at winterfell.dev

02The stack

Frontend
Next.jsMonacoTailwindFramer MotionGSAPWallet adapter
Backend
Express on BunwsBullMQOctokitStripeRazorpay
Data
PostgresPrisma 7RedisMinIO
AI
LangGraphPlanner, coder and finalizer models
Infra
Kubernetes JobsDockerGitHub ActionsEC2nginx

03Backend

What I solved on the backend

01

Every build runs in its own Kubernetes Job

Users run anchor build on code a model just wrote. That cannot happen on the API server.

Each command creates a Job with its own pod. The Job has a 900 second deadline, no retries, resource limits and an empty scratch workspace. It is removed 100 seconds after it finishes.

  • Kubernetes Jobs
  • Resource limits
  • Pod exec
02

A terminal that crosses three services

The browser types a command, and the output comes from a pod that did not exist a second ago.

The socket service checks the JWT and puts the command on a queue. A worker creates the Job, waits for the pod, runs the command and streams the logs back over a Redis topic for that user and contract.

  • ws
  • BullMQ
  • Redis topics
03

One command at a time per contract

Two builds on the same contract would fight over the same files.

The worker takes a Redis lock for the user and contract before it starts a Job. A build cache check runs first, so a repeat build can skip the queue.

  • Redis locks
  • Build cache
04

A push to prod is the deploy

Shipping by hand over SSH does not last past the first bad night.

GitHub Actions builds the server image with a layer cache, pushes it, then deploys to EC2 when the prod branch moves. A second workflow limits who can push there.

  • GitHub Actions
  • Docker
  • EC2
05

Rate limits for each route

One contract generation costs real money in model calls.

Each route has its own window. Contract generation allows 10 calls in 15 minutes, and cheap routes get a looser limit.

  • express-rate-limit
  • Per-route windows

04Design

What I solved on the design side

01

An IDE that fits in a tab

An editor, a file tree, a chat and a terminal all want the same screen.

The chat sits on the left and plans the work. The code, the file tree and the terminal share the right side, and files stream into the tree while the model writes them.

  • Monaco
  • File tree
  • Streaming files
The Winterfell playground with the chat, the file tree and the editor.
02

A terminal you trust

Build output from a far pod feels fake if it arrives in one block.

Logs show up line by line as the pod prints them, with the command, the state and the result each in their own colour.

  • Live logs
  • Terminal UI
The Winterfell terminal showing the output of an anchor build.