Crossroads

Inspiration

We're currently in our final year being undergraduates and a good number of our peers do not know what next after graduating. We understand that dilemma first-hand and we decided to build something around that problem. Most of the decisions that shape a life i.e, which career to chase, whether to take the risk, how much to sacrifice for stability most times get made with no way to see what's on the other side of them. We wanted to build a space as a game where someone could feel that weight without paying the real-world cost of finding out the hard way. It's a life decision simulator that's actually a game (not a boring worksheet), where every choice visibly compounds into who you become.

What it does

Crossroads lets you live an entire life in about fifteen minutes. You start by choosing a path: Student, Professional, Entrepreneur or you can design your own character entirely by typing a name (that summarizes your character) and a one-line situation and letting AI build a personalized story around it. From there, you make a sequence of decisions and face random events across four life stages, each one shifting four stats: wealth, knowledge, wellbeing, and network. Early stages are archetype-specific e.g., a student navigates campus life and debt, an entrepreneur navigates co-founder dynamics and burn rate, and later stages converge into universal territory: health, family, legacy.

At any decision point, you're not limited to the AI-generated choices, you can write your own response in free text, and the AI narrates the consequence while suggesting stat deltas the backend validates and clamps before applying. At the end, you don't only see the final outcome of your decisions, you see the two decisions that would have changed your trajectory most, with a full counterfactual stat comparison, and a personalized reflection on the patterns in how you played.

How we built it

The frontend is React + Vite; the backend is FastAPI. AI narrative generation runs on Google Cloud's Vertex AI using Gemini 2.5 Flash, authenticated via Application Default Credentials so no API keys ever touch the client. Both services are containerized and deployed on Cloud Run.

The core design principle we held throughout: AI writes narrative, code calculates outcomes. Every stat delta, every achievement condition, and every life-outcome formula lives in deterministic JavaScript i.e., the model never has authority over what happens in the simulation, only how it's described.

Challenges we ran into

Almost every layer of the stack threw at least one surprise. Gemini's "thinking" tokens silently ate our entire output budget on 2.5 Pro until we switched to Flash and disabled thinking entirely. A numeric-hallucination filter was blocking any sentence containing a number at all which had to be rewritten to be precise instead of blunt. Gemini routinely ignored our JSON schema instructions and invented its own field names, which meant building a normalization layer rather than trusting the model's output structure on faith.

Deployment surfaced its own round of bugs: a Dockerfile copying files to the wrong path, PowerShell silently mangling comma-separated environment variables into one mangled string, and a CORS configuration that needed updating twice. Regarding teamwork, we flowed effortlessly as a team and the only challenge was how distance affected collaboration, but we fixed that by communication via zoom.

Accomplishments that we're proud of

The custom archetype system is the one we're most proud of typing "a new pharmacist graduate who wants to go into research as a field of specialty" and watching the AI generate a coherent two-stage decision arc that actually reflects that life, not a generic reskin. We're also proud that Responsible AI and human-in-the-loop are things you can watch happen live while playing the game: an "AI-generated" vs "Offline mode" badge on every consequence, a guardrail rejection counter in the header, and a fully working fallback you can trigger by killing the backend mid-game.

What we learned

The biggest lesson was about trust boundaries with LLM output: never let a model calculate something that needs to be correct, and never assume its structured output will match your schema without a validation and normalization layer behind it. We also learned how much of "AI safety" in a real product is tedious plumbing (token budgets, timeout tuning, regex precision) rather than an exotic conceptual. And we learned that the fallback path deserves as much deliberate testing as the happy path, since it's the part most likely to be silently broken and most important when something does fail.

What's next for Crossroads

A persistence layer and a database so players can save and resume a life in progress. A version where two players make the different decisions for the same character side by side and compare where they end up. Deeper support for player-authored life events, not just player-authored choices, so the simulation can start from something genuinely your own. And tighter production hardening i.e., locked-down CORS, rate limiting on AI calls, and a real cost-monitoring layer now that the core experience is proven out.

Built With

• application-default-credentials
• artifact-registry
• claude-sonnet-4.6
• cloud-build
• cloud-run
• css
• docker
• fastapi
• gemini-2.5-flash
• gemini-cli
• google-antigravity
• google-auth
• google-cloud
• html
• httpx
• iam
• javascript
• nginx
• opencode
• pydantic
• python
• python-dotenv
• react
• tailwind-css
• uvicorn
• vertex-ai
• vite