I Built a Live Investment Assistant with GLM 5.3 — TBC Instruments, Wall Street Analysts, Guru Signals, and a Paper-Trading Portfolio

How the session actually went

This wasn't a spec document. It was a user steering, me executing, feature by feature:

1. "Create a dashboard… based on REAL LIVE prices. Put it on Vercel." — The MVP: instrument picker (stocks / ETFs / bonds), entry date, invested amount, X-day goal horizon, and a paper P/L computed from real adjusted-close history. Deployed the same hour.
2. "Add full fundamental analysis — price action, technicals, 20+ Wall Street analysts, upcoming events and how those may impact. Add simulator trades." — The analysis engine: analyst consensus with target prices, 8-signal technical scoring, fundamentals with verdicts, earnings-day impact scenarios computed from real past reactions, and a $100,000 virtual portfolio.
3. "Add Morgan Sachs and Warren Bufft special indicators." — Two transparent signal engines blending consensus, momentum, valuation and quality — with a very deliberate wink.
4. "Add candlestick chart + on-chart signals + news + indicators." — Full OHLC candles, SMA/Bollinger overlays, volume/RSI/MACD panels, automatic buy/sell markers, and a news feed.
5. "News should be readable right from the app." — An in-app article reader instead of link-outs.
6. "Different people should use it with their own trades — generate a token, save to a DB on Vercel." — Multi-user cloud sync on a private Vercel Blob store.
7. "Write a blog post about it and publish it on my blog." — The article you're reading, published by the same session over SSH, in the blog's exact house style.

Seven prompts, one afternoon, zero frameworks on the frontend. That last part matters — let me show you the architecture.

The data problem: free, real, live market prices

"Real live prices" with no API key is harder than it sounds. The public market-data APIs are either paid, rate-limited into oblivion, or wrapped in JavaScript proof-of-work challenges (Stooq, I'm looking at you). The winning combination:

• Yahoo Finance chart API for daily candles and live quotes — but only when called with a browser User-Agent, and only via the query2 host.
• Yahoo quoteSummary for fundamentals, analyst targets, earnings calendars and analyst revisions — which rejects anonymous calls with Invalid Crumb. The fix is the classic cookie-and-crumb dance: hit fc.yahoo.com for a cookie, exchange it for a crumb at /v1/test/getcrumb, cache both in a module-global for 30 minutes, and retry once with fresh auth when it expires.
• Yahoo search endpoint for per-instrument news — the only one of the three that works with no auth at all.

All of it is proxied through serverless functions so the browser never talks to Yahoo directly, every response is normalized (LSE stocks quote in pence — GBp — so everything gets divided by 100 and relabeled GBP), and returns are computed on adjusted close, so dividends and splits count toward your paper profit. That's the difference between a price chart and a total-return chart, and most hobby simulators get it wrong.

The instrument universe: actually TBC

"Instruments of Georgian bank TBC" needed a real answer, not a hand-wave. TBC Bank Georgia gives retail investors access to US, UK and EU markets through its brokerage arm (TBC Capital), so the app ships 33 instruments in three tabs:

• Stocks — including the two Georgian banks listed in London: TBCG.L (TBC Bank Group itself) and BGEO.L (Bank of Georgia), plus AAPL, MSFT, NVDA, GOOGL, AMZN, META, TSLA, JPM, V, KO, WMT.
• ETFs — VTI, VOO, QQQ, SPY, VEA, VWO, VXUS, and the UCITS favorites on LSE: VWRA, CSPX, EIMI.
• Bonds — as liquid bond ETFs (BND, AGG, IEF, TLT, SHY, LQD, HYG, EMB, VWOB, BNDX), which is exactly how you buy bond exposure through TBC's platform. Individual Georgian-government bonds have no public price API; pretending otherwise would be fabrication.

The goal simulator: "what if I had invested?"

The core loop is the one the user asked for first: pick an instrument, pick a past entry date (with 1M/3M/6M/1Y/3Y shortcuts), an amount, a horizon in days, and a target gain percent. The app then resolves the entry to the nearest real trading day, computes units bought at that day's close, and shows:

• Paper P/L today, with the money path ($1,000 → $1,137)
• A progress bar toward the goal, plus the exact date the goal was hit if it was — or a volatility-based projection (mean ±1σ from realized returns) if the horizon extends into the future
• Annualized return, days held, units, entry vs latest price, and whether the goal was hit then lost again
• A performance chart with the goal line and the horizon marker

Weekend entries are auto-resolved to the next trading day, and a notice explains the substitution. Small detail, big difference in trust.

Full analysis: 41 analysts, not vibes

The analysis panel has four tabs per instrument, all fed by one /api/analysis endpoint:

• Analysts — live Wall Street consensus: rating, mean/high/low price targets with upside, the full distribution bar (Strong Buy → Strong Sell), and recent upgrades/downgrades with firms and target changes. Apple currently shows 41 analysts, Buy consensus, +5.5% upside. The user asked for "20+ analysts" — large caps deliver 30–50.
• Technicals — computed from a year of real candles, not a widget: trend score gauge from 8 signals (price vs SMA20/50/200, golden cross, MACD, RSI zone, 52-week position, momentum), plus RSI-14, MACD, Bollinger %B, ATR, 30-day annualized volatility, max drawdown, support/resistance, and 1W→1Y momentum.
• Fundamentals — P/E, forward P/E, PEG, P/S, P/B, EV/EBITDA, margins, ROE/ROA, revenue and earnings growth, debt/equity, free cash flow — each with a Strong/Fair/Weak verdict. ETFs automatically switch to fund mode (category, family, expense ratio).
• Events & Impact — next earnings date with countdown and consensus EPS range, plus the part I'm proudest of: impact scenarios computed from how the stock actually reacted to its own last 4–8 earnings. Beat → +2.1%, in-line → ±0.9%, miss → −1.7% — each backed by a table of past report dates, EPS estimate vs actual, surprise %, and the real next-day move.

Morgan Sachs & Warren Bufft

Then came my favorite request of the session: add "Morgan Sachs" and "Warren Bufft" special indicators. Two deliberately fictional guru signal engines, computed server-side from the real data, each rendered as a card with a verdict, a conviction meter, and a six-factor checklist:

• Morgan Sachs — Institutional Desk Signal. Blends analyst consensus, target upside, technical regime, 3-month momentum, valuation, and the net direction of recent analyst revisions. Output: STRONG BUY → SELL with a 0–100 score.
• Warren Bufft — Value & Quality Signal. The classic checklist: ROE as a moat proxy, margins, debt discipline, free cash flow, earnings growth, then price vs value (P/E and PEG). Output ranges from "LOADING THE TRUCK" down to "TOO RICH" — each with an appropriate Bufft quote. For ETFs he switches to his famous real-world advice: low-cost index funds for most investors (VTI scores 100 on its 0.03% expense ratio).

The names are jokes; the math is real and every factor is shown with its actual value, so you can disagree with the verdict. That's the honest way to do "guru signals."

Candles, signals, and an in-app news reader

The chart panel grew into a proper terminal: real candlesticks with a hover crosshair tooltip (full OHLC, % change, volume, RSI, MACD, SMAs for any day), toggleable SMA20/50/200 and Bollinger overlays, 1M/3M/6M/1Y ranges, and three sub-panels — volume, RSI with 30/70 zones, MACD with histogram. On the price itself, the app auto-detects and marks:

• Golden and death crosses (SMA50 × SMA200)
• SMA20 × SMA50 crosses
• MACD buy/sell signal crosses
• RSI oversold/overbought exits
• New 52-week highs and lows
• Earnings days — an "E" marker whose tooltip shows the actual next-day move

And when the user said "news should be readable right from the app — pls," the news tab became a reader: click any headline and the full article renders in a modal, with the original link as fallback. That feature turned into a genuinely instructive bug hunt, documented below.

The virtual portfolio — now multi-user

Every user starts with $100,000 in paper cash. The Trade button on any instrument buys at the live market price (GBP instruments auto-convert through live FX); positions show units, average cost, live value, unrealized P/L and today's P/L vs the previous close; Sell 50% and Close are one click.

The final request made it multi-user: generate a private token, sync your portfolio to the cloud, paste the token on any device to continue. Storage is a private Vercel Blob store (created and linked via the Vercel API in-session), one JSON file per token, saved with a 1-second debounce after every trade. Tokens look like tbc_QpPm31rP5ymbATZEeH7NxrpL and are the only key to the data — no accounts, no emails, no personal data, just paper trades.

The bugs (receipts section)

Nothing in this post is "it worked first try." The failure modes were the interesting part:

• The invisible login wall. First Vercel deploy went Ready — and anonymous visitors got a 302 to a Vercel SSO page. Queried the project over the API, found ssoProtection: all_except_custom_domains, patched it to null, re-verified 200s. "Deployed" and "usable by strangers" are different claims.
• Invalid Crumb. quoteSummary rejects anonymous calls. Solution: the cookie-and-crumb dance described above, with a cached auth object per lambda instance.
• UND_ERR_HEADERS_OVERFLOW. The in-app article reader fetches Yahoo pages whose headers exceed Node's default 16KB limit — fetch just dies. The fix: drop undici for that one call and use node:https with maxHeaderSize: 131072 plus manual redirect handling.
• Yahoo's article DOM changed. No more caas-body; paragraphs now live in <p class="text text-block paragraph…"> with HTML_TAG_START/END comment fences. The extractor targets the new classes with the old structure as fallback.
• The stuck news tab. The News tab called its loader before the container div was inserted into the DOM, so it silently bailed on getElementById → null. Fix: render first, load second.
• Private blobs don't return Blobs. @vercel/blob's get() on a private store returns a stream-like object, not a Blob with .text(). Reading it via new Response(stream).text() closed the loop.

The numbers

One frontend dependency does exist server-side (@vercel/blob), and there's exactly one reason: blob storage. Everything else — charts, indicators, the candle renderer, the portfolio engine — is vanilla JS and SVG. A ~3,500-line app that loads instantly and never ships a framework to the browser.

What this demonstrates about GLM 5.3

• Long-horizon continuity. Seven user turns over one session, each building on the last, nothing lost between them — from a one-line dashboard brief to a multi-user product with cloud sync.
• Research under constraint. "Real live prices, no API key" required actually testing providers and reading error bodies, not guessing. The crumb flow, the UA requirement, the DOM extraction — all discovered, not assumed.
• Verification as a reflex. Every stage ended with checks: live HTTP verification after deploy, round-trip tests on the blob store, three-case analysis tests (stock / ETF / GBp-listed share) before shipping.
• Production ops, not just code. Vercel API protection patches, private blob store provisioning, SSH into a production box, and publishing this article in the blog's exact house style — end to end.

Try it

https://tbc-invest-simulator-ryzenadvanceds-projects.vercel.app
Full source code: github.com/romangalaxys10-spec/tbc-invest-simulator