ForgeView · Screens

Screens for the work, built from the tools you already have

Once the tools for your systems exist, a screen is a short piece of configuration on top of them. It can bring together data from several systems, open the detail behind any row, and carry the actions people need, each one confirmed before it runs.

Part oneUsing a screen

01

Chat answers a question. A screen holds the work

Some questions are asked once. Others are asked every morning by the same people, and the answer is a list they have to work through.

Which orders are at risk this week. Which items are about to run out at one site while another has plenty. Which deliveries arrive today without a dock. Nobody wants to type these into a chat each day. They want a screen they can open, filter, sort and work from, with the answer already there.

ForgeView is that screen. It shows live data from your systems in a grid people can filter, search, sort and export. Choosing a row opens its detail underneath, and the actions people need sit on buttons above the grid. Screens are listed by category in ForgeView, so people find them where they expect them. The examples above are three screens built this way.

02

Many systems, one table

The useful screens are rarely about one system. An order at risk is an ERP promise, a warehouse that has not finished picking and a carrier that has not been booked. Each system knows its part. None of them shows the whole.

A ForgeView screen can. A short script behind it asks each system for its part, joins the answers and returns one row per order. When someone opens the screen, they choose a connection for each system it needs, and from then on it is one grid.

One row, three systems

ERPSO-48290 · Northwind Supply · promised Thu 14
Warehouse East2 of 3 lines picked
TransportCarrier ETA Fri 15
SO-48290Northwind SupplyThu 142 of 3 pickedFri 15High
Figure 1. Each system answers for its own part. The script behind the screen joins them on the order number and works out the risk.

Because the screen reads from the systems themselves, it is as current as they are. There is no copy to refresh overnight and no report that was right yesterday.

03

Every row opens its detail

A grid is good for finding the rows that need attention. To decide what to do about one of them, you need to see what sits behind it.

Choose a row and its detail loads underneath: a second screen, filled in from the row you chose. An order at risk opens its pick tasks from the warehouse, so you can see which line is short and where it should be picked from. The detail can come from a different system than the list above it, and you never type the order number again.

Because the detail is a screen in its own right, it is built once and reused. The pick tasks screen that opens under an order can also be opened on its own.

04

Act where you look

Seeing the problem is half the job. The other half is doing something about it, and on most screens that means leaving for another system.

On a ForgeView screen the actions are buttons above the grid: raise the priority of an order, release it to a wave, anything your team has written a tool for. An action can work on one row or on many. What it needs comes from the rows you selected and the filters you set, so nobody retypes an order number.

Nothing runs without a check. Every action first shows the rows it is about to change and waits for you to confirm. It then runs once per row, reports each result, including any that failed, and refreshes the grid so you see the change straight away.

The screen shows the problem, and the fix is one button away.

Behind each action is a tool, just as behind each column. That is what keeps the two parts of this page connected: anything your team can write as a tool can become a column, a detail screen or a button.

Part twoBuilding a screen

05

It starts with tools

A screen does not talk to your systems. Tools do. A screen decides how their answers look and which tools its buttons call.

Most of the work is already done by the time anyone builds a screen. The tools that chat and agents use, written in SQL, in a system's own language or in Python, are the same tools a screen uses. A simple screen is one tool on one system: its inputs become the filters and its outputs become the columns.

For a screen that spans systems, a short Python load script does the gathering. It calls a tool on each system, joins the results into one table, puts dates and numbers into one format and returns it as the grid. It is written in the Script Editor in Forge Studio, run against test data with its output in front of you, and kept in git next to the screen.

What the load script for this screen does

  1. Ask the ERPCalls a tool for open orders in the promised dates from the filter.
  2. Ask each warehouseCalls a tool for picking progress on those orders, East and West.
  3. Ask transportCalls a tool for the booked carrier and arrival time.
  4. Join and shapeOne row per order, dates in one format, a risk value worked out from the three.
  5. Return one tableIt becomes the grid. The builder runs it once to find the columns.
Figure 2. The steps of one load script, written once by your team. A simple screen needs no script: one tool on one system is enough.

06

Wire the tools together. The screen is generated

In ForgeView, tools become the parts of a screen. One tool fills the grid, others become buttons, and another screen becomes the detail. In the designer you wire them together, and the screen is generated from that.

A new screen in Forge Studio starts with one question: what powers it? Either a published tool, for a screen that reads one system, or a Python script, for one that merges several. Everything after that is filled in from the answer.

Pick a tool and the screen builds itself a first draft. The tool's inputs become the filters and its outputs become the columns, already labelled. From there it is a matter of taste: switch filters and columns on or off, drag them into order, and click a column to format it as a date, an amount or a status. Until you preview it, the grid shows placeholder rows, so you can arrange the screen before touching any data.

Actions are added the same way. Each button gets a label, a style and an icon, and then something to run: a tool or a Python script. The tool does not have to live on the same system as the screen. In the example, a screen that reads the warehouse has a button that opens a supplier claim in the ERP.

A detail screen is chosen from the screens that already exist. You say which column of the row fills which input of the detail screen, and from then on choosing a row loads its detail underneath. Labels, dropdowns and validation come from a shared field dictionary for each system, so a label fixed once is fixed on every screen.

Because the screen is configuration, changing it later is just as small. A new column is a switch. A new action is a tool and a button. Nobody has to rebuild a page.

07

Ship it through git, like everything else

A screen is one small file, the screen definition, kept in your own repository with its script beside it. It goes live the same way your tools do.

Preview first. It opens the real screen with live data on a test connection, with search across all columns and export, exactly as people will use it. Nobody else can see it yet.

When the screen is ready, you save it and push it from the studio: you see the changed files and their differences, name a new branch and write a commit message. The definition then goes through approval in a pull request in your git provider, the same place your other code is reviewed. Once it is approved and merged, it becomes available to the whole organisation, listed under its category in ForgeView, with no deploy step: ForgeView checks the repository for changes about every 30 seconds. If something is wrong, the history shows what changed and who approved it, and the previous version is one revert away.

08

What to know before you build one

  1. A screen shows what its tools returnIf a system has no tool, it is not on the screen. Write the tool first, then add the column.
  2. Joining systems is the script's jobThe screen does not match rows across systems by itself. The load script decides how records belong together.
  3. An action does what its tool doesIt is confirmed before it runs, and it can only change what the tool and the chosen connection allow.
  4. Nothing reaches people without approvalA screen definition is reviewed and approved before the organisation sees it.
  5. Screens are grids todayFilters, a grid, actions and detail screens. Charts on screens are not part of ForgeView yet; use dashboards and reports for those.