Stockast

Stockast is a TypeScript-based stock forecasting library built to support forecasting workflows directly inside a JavaScript/TypeScript application stack. The project was created to remove the need for Python-only forecasting tooling when building stock analysis dashboards, internal research tools, or other web-based analytics applications.

Background

Many forecasting and quantitative analysis libraries are primarily available in Python. That ecosystem is strong, but it creates friction when the rest of the product stack is built in TypeScript, especially for web applications using frameworks such as Next.js. In that setup, forecasting logic often has to be separated into a different service, wrapped through an API, or executed through an additional bridge layer.

Stockast was built to explore a different approach: keeping forecasting capabilities in the same TypeScript environment as the rest of the application. The goal was not only to implement forecasting models, but also to make them usable in a practical stock analysis workflow without depending on a separate Python service.

What the project does

Stockast provides a forecasting toolkit for stock-related analysis workflows in TypeScript. The project includes:

• forecasting model implementations for time-series experimentation
• backtesting utilities for evaluating model behavior on historical data
• CLI tooling for running forecasting workflows outside the UI
• integration support for use inside a Next.js-based stock analysis dashboard

Rather than positioning the project as a standalone research notebook tool, the implementation was shaped around actual application usage. That means the library was designed to fit into a broader product workflow where forecasting outputs need to be consumed by other parts of the system, displayed in a dashboard, or reused across multiple analysis features.

What I built

I built the forecasting library from scratch in TypeScript and structured it as a reusable internal tool rather than a one-off experiment. The implementation covered both the forecasting side and the surrounding developer workflow needed to make it practical.

The main areas I worked on were:

• implementing forecasting-related logic in TypeScript for stock analysis use cases
• building backtesting utilities to compare outputs against historical data
• creating a CLI so forecasting runs could be executed outside the web interface
• integrating the library into a real dashboard workflow built on Next.js
• designing the code structure and API surface so the library could be reused across multiple features instead of being tightly coupled to one script or page

Technical focus

A large part of the project was not only about numerical logic, but about making the library ergonomic inside a TypeScript codebase. In practice, that meant thinking carefully about how the API should be shaped, how inputs and outputs should be typed, and how forecasting utilities should interact with the rest of an application without creating unnecessary complexity.

Some of the technical concerns involved in the project included:

• keeping the forecasting workflow usable in a TypeScript-first environment
• designing function signatures and abstractions that remain readable in application code
• making backtesting utilities straightforward to run and inspect
• supporting dashboard integration rather than limiting usage to isolated scripts
• balancing flexibility with maintainability so the project could continue evolving over time

Development scope

The project moved beyond a small prototype and was developed as an actively used codebase.

Development highlights:

• 43 commits completed in one month
• 9 pull requests merged in May 2026
• continued active development after the initial implementation phase

Outcome

The result was a working forecasting library and CLI that could be used directly inside a stock analysis workflow built with TypeScript and Next.js. More importantly, the project validated that forecasting-related tooling does not always need to live in a separate Python stack when the surrounding product is already built around TypeScript.

Key takeaway

One of the main takeaways from this project was that the hardest part was not simply implementing forecasting logic. The more important challenge was designing a developer experience that made the library practical in real application workflows. A forecasting library can be technically correct, but if the API is awkward to use inside dashboards, scripts, or analysis pipelines, it becomes much less valuable in day-to-day development.