Designing a Full-Stack Investment Decision Tool for a Private Family Office

I was brought on to design and research for a private family office that manages a concentrated equity portfolio. They had a clear problem: their workflow (a patchwork of broker terminals, Telegram groups, and personal spreadsheets) couldn't keep up with how they actually wanted to trade. They needed a tool that could do three things:

1. Scan, rate, and act. Scan stocks listed on NSE and BSE against technical parameters (consolidation patterns, volume breakouts, RSI momentum), score them on a 0–100 scale, generate daily picks across three timeframes (intraday, swing/BTST, positional), and let them buy directly from the same screen.
2. Watch the news. Pull every corporate action, board meeting, financial result, and shareholding change from NSE and BSE exchange feeds, classify each one for investment relevance, and surface the ones that matter before the market prices them in.
3. Protect capital without babysitting. Once a position is open, manage risk with trailing stop-losses that adjust in real time as prices move, and automatically place the sell order when the stop triggers.

The team was small (two principals and one analyst) and they had zero interest in learning a new application. They already lived in spreadsheets. Whatever I designed had to meet them where they were.

Before I designed anything, I sat with the principals during market hours for two full weeks. Not to interview them, but to watch. I wanted to map the decision chain: what information triggers a trade idea, what parameters confirm it, what makes them pull the trigger, and what makes them exit.

The Existing Workflow (Before)

Every morning at 8:45 AM, the analyst would open four browser tabs: Shoonya (the broker), Chartink (for technical scans), NSE and BSE announcement pages, and a Google Sheet tracking open positions. He'd run 3–4 pre-set scans on Chartink, copy promising tickers into the sheet, manually check RSI and volume on TradingView, and flag candidates for the principals.

• The scan-to-decision loop took 25–40 minutes, an eternity when the market opens at 9:15.
• Stop-losses were static, set once at entry and never adjusted. Profits that existed on screen disappeared because no one was watching at the right moment.
• Corporate actions were checked once a day, in the evening. Time-sensitive announcements were sometimes caught a full day late.
• Nobody tracked true trading costs. "Zero brokerage" on Shoonya masked real costs of 0.10–0.15% per round trip in statutory charges.

Working with the development team, I decided to build the system on Grist, an open-source spreadsheet platform, for one reason: the team already thought in rows and formulas. Rather than make them learn a new app, we embedded five custom widgets directly into their existing spreadsheet. Each widget sits in a panel in the Grist layout (resizable, rearrangeable, linked to the same data tables) and draws from a shared real-time data feed underneath. The system doesn't just show data. It scans, scores, buys, sells, and manages stops, all from within the spreadsheet.

SmartPicks is the centrepiece, the feature that killed the analyst's morning routine of running manual scans, copying tickers into a sheet, and checking indicators one by one.

Every 15 minutes during market hours, the system runs a technical scan against the configured index (Nifty 50, 100, or 500), scores each stock on five weighted parameters, and shows the top 10 as picks you can act on, with entry price, target, stop-loss, and risk-reward ratio already calculated. The principal can buy directly from the picks list.

The Scoring Model (0–100)

Each stock that passes the initial filters gets a score out of 100. We calibrated the weights over three months of paper trading and adjusted them twice after going live:

NSE and BSE publish RSS feeds for announcements, corporate actions, board meetings, financial results, and shareholding patterns. Across both exchanges, that's thousands of items, too many for three people. But buried in the noise are time-sensitive items: a buyback announcement, a promoter quietly increasing their stake, a dividend declaration that hints at strong cash flow.

This was the feature the principals asked about most. The problem wasn't that they didn't use stop-losses. It was that static stops don't protect profits. A stock runs up 8%, then pulls back and hits your original stop at -2%. You had a winning trade and still booked a loss.

A trailing stop fixes both problems. It moves up with the price, locking in gains as they happen, and when the price pulls back past the trailing level, the system automatically places the sell order through the broker. No one needs to be watching.

=TRAILING_STOP_LOSS($Symbol, 2.5, $ExecuteTSL, $Exchange)

That's it. $Symbol is the stock, 2.5 is the stop percentage (2.5% below peak), $ExecuteTSL is a checkbox column that arms it, and $Exchange picks NSE or BSE.

The portfolio widget ties everything together. It answers: where does the money stand, right now, after all costs?

"Zero brokerage" is a marketing claim, not a financial reality. On Shoonya, CNC (delivery) brokerage is indeed zero. But every trade still incurs six statutory charges:

The formula system made the spreadsheet foundation genuinely powerful. The moment you enter a formula like =LIVE_PRICE($Symbol, $Exchange) into a column, the system immediately starts overlaying real-time data from Redis into that cell. No delay, no save-and-refresh. The formula tells the system what data to stream, and the overlay engine pushes it to the cell in sub-100 milliseconds.

Everything described above (live prices, trailing stop levels, order status, P&L numbers ticking up and down) depends on one technical trick: never write live data to the document.

Grist stores data in SQLite. When a formula result changes, it triggers a recalculate → write → push cycle that takes about 300ms. For a portfolio with 30 symbols updating 10 times per second, that's not possible.

The solution: the system injects HTML overlays directly on top of formula cells. The formula =LIVE_PRICE("RELIANCE") stores the last-saved price. The overlay, a positioned element matched to the cell's coordinates, shows the real-time price from the WebSocket feed. Price ticks flow through Redis to a caching layer, then to the browser in sub-100 milliseconds. No disk writes. No recalculation loop.

Beyond the structured widgets, I designed an interface around a conversational agent we call "Cyber Agent." It runs Claude Code under the hood and has access to financial data tools, so the team can ask it questions in plain English and it'll look up quotes, pull data, or run analysis.

It also has access to a built-in Jupyter notebook. The analyst can ask the agent to pull historical data, run a correlation analysis, plot a chart, or backtest a strategy, and the agent writes and executes the Python code right there in the notebook.

I should have built order entry before the screener. The team's core loop is: see pick → decide → buy. SmartPicks handled "see." The scoring handled "decide." But "buy" was still a formula you had to type out. The gap between seeing a pick and placing the order should be one click.

Charges should have been visible from day one. The team had already built a mental model of "P&L = realized profit" before I added the charges breakdown. Showing the real cost later felt like bad news, even though the money was always being spent.

Paper trading doesn't tell you how the UI feels with real money. There's a difference between a test portfolio dropping ₹2,000 and watching your own money drop ₹2,000. Font sizes, how saturated the red is, where the P&L card sits. Several of these I only got right once real capital was at risk.

• One-click order entry pre-filled from SmartPicks with symbol, quantity, limit price, and stop-loss.
• Risk dashboard sector concentration, drawdown metrics, position correlation.
• Backtesting run the scoring model against historical data to validate parameters.
• Position sizing auto-calculate lot sizes based on a 2% risk-per-trade rule.