From a Table to a Map

Everyone has seen this kind of table before. Options as rows, criteria as columns, ratings in the cells. This one compares twelve programming languages on seven criteria, each rated from one to five stars.

The input table, as you would fill it in: twelve options, seven criteria, one rating per cell. This is exactly the file Standpoint reads.

The table is honest, complete, verifiable. It is also unreadable. You have just experienced that. Eighty-four cells of stars to compare in your head, seven columns to weigh against one another: the eye gives up. The choice falls back on gut feeling, the very thing the table was meant to prevent. Worse: two people acting in good faith read the same table and pick two different winners.

Standpoint turns that table into a map. Each option becomes a point on a plane. Two nearby points are two similar profiles. The ends of the axes carry plain words, in the language of your columns. The map answers a single question: where do you stand?

What it is for

You can spot straight away the questions that call for a map. There are several options, several criteria. And you have to say where each one stands against the rest. Settling on a cloud provider for the next three years. Choosing the language a team will write in for the next five. Placing your product against six competitors before a board meeting. Cutting fifteen applications down to a shortlist, and being able to say why those ones.

The repository holds four demonstration tables, which show what the tool accepts. Cloud providers. Laptops, where price and weight are marked as columns where less is better. French electric cars, whose table comes back with a French title and French axis names. And the programming languages from the introduction. These subjects have nothing in common except the shape of the file: names in the first column, numbers everywhere else.

It is worth saying what the tool cannot do, before it disappoints. For one or two columns, a map is useless; an ordinary chart does better. For a ranking on a single criterion, sorting the column is enough. PCA also serves as a computing step inside a machine-learning program. There, scikit-learn does the job. No figure comes out at the end. Lastly, Standpoint maps a table that already exists. It fetches no data and checks no rating. If you filled your table in badly, it will never know.

Motivation

Positioning maps are a staple of marketing and consulting. People sketch them on whiteboards to place brands, products, competitors. The method that builds them properly is called Principal Component Analysis, or PCA. It is more than a century old: Karl Pearson laid out its geometry in 1901, Harold Hotelling put it in shape in 1933. The easiest way to picture it is a school report card. A student has eight marks, one per subject. But two numbers are usually enough to place that student: more of a science type, more of a humanities type. PCA does the same with a table. It looks for the two or three directions along which the options really differ. A whole row of ratings then comes down to two numbers, which keep most of what sets it apart from the rest.

That a method from 1901 is still the right one in 2026 deserves an explanation. Today's reflex is to throw a large model at everything. But twelve rows and seven columns is a very small problem. PCA settles it in milliseconds, with no training and no data from anywhere else. If you want to check, you can redo the arithmetic by hand. Nobody caught up that century of head start, because there was nothing to catch. The right answer already existed for projecting a small table of numbers.

So the method has been known for a long time. The time does not go there: it goes into everything around it. Turning the map so it reads the right way. Naming the axes with words a management committee understands. Coloring, placing the labels so they do not overlap, exporting at print quality. That is the work Standpoint automates. A single command reads your table, in CSV or Markdown, two common ways of writing a table in plain text. It produces the figure, as SVG and PNG. It also produces a YAML file, readable as-is, with every coordinate and every coefficient.

The tools that already exist fall into two families. Neither does the whole job. On one side, the statistical toolkits: prince or the PCA in scikit-learn for Python, FactoMineR and factoextra for R, the statisticians' language. The computation is impeccable. You can run it again. But what they hand you is raw axes and numbers. Naming the axes, turning the map, making it presentable. All of that is left to you. On the other side, the layout tools: a four-box slide, a Canva template, or the famous magic quadrant from the firm Gartner. The result is shareable at once, but every dot is placed by hand. Nothing comes from the data, nothing can be run again. The axes mean whatever the author decided they mean.

The quadrant everybody looks at

In that second family, one case is worth a stop: it is the most looked-at positioning map in the world. Gartner is an American firm. Its business is analyzing software markets for the companies that buy. Every year, for dozens of markets, it publishes a figure called the Magic Quadrant. Two axes, four boxes. The horizontal axis measures vision, that is, what the vendor has understood about the market and where it is going. The vertical axis measures execution, that is, what it can actually ship today. The four corners carry names that have entered everyday speech. Top right, the Leaders. Top left, the Challengers, who ship well but see the market badly. Bottom right, the Visionaries, who see correctly but cannot yet ship. Bottom left, the Niche Players.

You have to understand what that box weighs. Appearing in it is already an achievement, because Gartner only places companies it judges important enough to follow, and many work for years to get in. Once inside, the box moves money. A CIO defending a seven-figure purchase to a board finds in it a warrant everyone understands at a glance. Some tenders are even written by copying it out.

Since the box weighs that much, how it is built becomes a real question. It even went to court. In 2009 the Californian vendor ZL Technologies sued Gartner for defamation: it held that its place in the box was costing it customers. Gartner answered that the quadrant is an opinion, not a statement of fact. The distinction carries weight in American law: you can prove a statement of fact false, not an opinion. The federal court for the Northern District of California agreed in 2010, and the appeal court upheld it.

There is nothing shameful in that, quite the opposite. An expert opinion, owned as one, beats an invented measurement. Gartner's rests on a year of interviews, vendor briefings and calls to their customers. No computation replaces that work. You only have to say precisely what you are looking at: the position of a dot is a judgment. A judgment cannot be redone identically.

Standpoint does not aim at that expertise and does not replace it. It promises far less, but what it promises can be checked: the position of a dot comes from a table you can read, by a computation you can run again. A dot that surprises you traces back to its row and its ratings. The price of that promise should be said too. A map is worth no more than the ratings in the table. Filling in eighty-four cells by instinct, then projecting them cleanly, creates no knowledge. It makes what you put in visible and arguable. That is already a lot. It is not knowing.

So Standpoint aims for the corner nobody occupies. A map that is computed, like the statisticians'. And finished, like the layout tools'. It adds one new idea. A language model then reads the axes that came out of the computation. These programs handle text, the way ChatGPT does. This one gives the axes names in plain words. Using PCA for a positioning map is a classic. Having a machine name the axes is much less so.

That leaves the question of whether anyone but me can use it. The package installs from PyPI, the public repository of Python libraries. The tests run again by themselves on every change to the code. Four example sets sit in the repository with their figures. The documentation exists in English and in French. And the same engine is reached through seven different paths, described at the end of this article.

One choice matters to me, even though it gives up the comfort of online services: everything runs on your machine. The computation, the drawing, and even the names of the axes. That last one is handled by a language model installed at your end. Ollama launches it. Ollama is a program that runs open models on your own computer. Your table sometimes holds internal notes about your competitors. It never goes anywhere else.

How it works

Even before the computation, one quiet decision protects you. A cell left blank is not ignored: it gets the lowest rating in its column. So a gap can never flatter an option. Which makes it impossible to conveniently forget to rate yourself on the awkward criterion.

First step: put the criteria on an equal footing. A comfort rating out of 5 and a price in thousands of euros cannot be compared as they are. Without care, the column with the biggest numbers would crush all the others. So from each column \(j\) we subtract its mean \(\mu_j\), then divide by its standard deviation \(\sigma_j\), which measures how far its values usually stray from that mean:

After this rescaling, every criterion weighs the same: a difference of one means "one standard deviation above average" everywhere.

Second step, the heart of the computation. Picture the options as a cloud of points in a seven-dimensional space, one dimension per criterion. Nobody sees seven dimensions, but the cloud image is enough: each language is a point, placed by its ratings. PCA looks for the plane that, seen head-on, spreads that cloud out as much as possible. That plane rests on two directions \(v_1, v_2\): the ones along which the options pull apart the most. Put plainly, they are the two directions that carry the most difference between the options. Mathematicians call them the top two eigenvectors of the covariance matrix, the table saying which criteria vary together. The position of an option on the map is then its shadow cast onto that plane:

The angle brackets \(\langle\cdot,\cdot\rangle\) denote the scalar product, the operation that measures how far a point advances along a direction. A flat map remains the summary of a richer space. The share of information it keeps can be measured, and Standpoint prints it on the figure:

Around 80%, the map tells the table's story faithfully. Below that, read it as a sketch.

Third step, orientation. A raw PCA map comes out facing any which way: nothing forces the "good" corner to sit at the top right. So Standpoint turns the plane to put your reference option there, the one whose position you want to tell. One edge case is handled. A reference rated top marks on everything would land far away from everyone else; it is then placed just past the best competitor, where the map stays legible.

Then comes what the map highlights, and here too nothing is decided by hand. Four options are singled out, each chosen by geometry alone. The leader is your reference, top right. The weakest is the one losing on both axes at once. That leaves two challengers, once the leader is set aside. The first reaches highest up the vertical axis. The second reaches furthest along the horizontal. Those two deserve a look, because each represents one extreme better than anyone, without winning.

Color follows the same rule. Every competitor takes its hue from the direction it sits in relative to the center of the map, the hues being spread right around the color wheel. Two neighbors on the map therefore have neighboring colors, which reads without thinking about it. The legend is ordered the same way as the map, from the top-right corner downwards.

Last step, the words. PCA axes are blends of your columns. Those blends can be read. One axis may lean mostly on performance and concurrency, the other on ease of learning and job market. A model installed at your end reads those weights and gives a name to the four ends, always as a quality. It writes in the language of your table, which it recognizes from the column names: English, French or Spanish. A column can carry the mark "(↓)", as in Price (↓). It means less is better. The name chosen then states the benefit, not the drawback. It will say "Affordable". A guard filters out acronyms, negations and opposite words before they reach a label.

A word on what that model is, since the term covers very different objects. A language model is a program trained to continue text. ChatGPT is one, a very large one. That size is measured in parameters, the internal dials learned during training. The biggest ones count hundreds of billions and run only in data centers. Distillation means teaching a small model the answers of a large one, on one precise task.

The one used here is tiny: a Qwen3 of 0.6 billion parameters, distilled for three very limited tasks. The first names the four ends of the axes. The second puts words in the right number, singular or plural, so the labels sound right in both languages. The third proposes a rating from one to five where a cell is blank. That third task touches the position of the dots. The proposed ratings enter the computation like any other. They move the dot on the map. They are displayed precisely so that you correct them. On this project's measurements they land within three quarters of a point of what a large model would propose, on a one-to-five scale that stays subjective.

That small size is the point. Everything that can be computed is computed by the PCA. The model steps in only where there is nothing to compute. It puts a word on a blend of columns that already have names. It proposes a number where the cell is empty. It never sees your ratings. It sees weights, column names, and for the filling, the row names. This work does not call for one of the very large models of the moment; it calls for one that fits on a laptop and does not leave the room.

One training result is worth telling, because it runs against intuition. Two models had first been distilled, one per language. A third, trained on both languages at once, was added to see what specializing brought. The bilingual one won, everywhere. For naming the axes, the two specialists topped out at 90%; the bilingual one reaches 100% in each language. What costs a model this size the most is not the meaning. It is the exact shape of the answer. And that shape is the same in both languages. Training in two languages means seeing that shape twice as often. So one model ships, better everywhere and half as much to maintain.

The same standard led to removing a model instead of adding one. Standpoint checks its own figure and answers three questions. Is the leader really at the top right? Are the labels legible? Is the legend visible? A vision model used to handle that, by looking at the image. Its answers were counted across the 1,480 examples recorded during distillation: two of the three questions came back "yes" all 1,480 times. The third turns on the sign of a coordinate, which the program already knows exactly. So a model was being asked to look at a picture for numbers we had to hand. The program now computes that check itself: no model, instantly, offline.

The best demonstration is to turn the tool on itself. The map below compares Standpoint to the other ways of drawing a positioning map, on seven criteria. Standpoint produced it itself, from a table of ratings I filled in. One caveat. Standpoint is the reference row, so it ends up at the top right by construction. And the ratings in the table are mine. Change the reference and the same map rearranges itself around another tool.

The same engine is reached through seven paths. A Python library (import standpoint). Two twin commands to type in a terminal. A graphical interface in the browser. An HTTP API, that is, a door through which other programs call the tool over the network. A server for AI agents, speaking the Model Context Protocol (MCP). The seventh path is a fully static build. The engine is translated into WebAssembly, a format every browser knows how to run. It therefore runs at the visitor's end, with no server. That is the one online at deraison.ai/standpoint: paste your table, get the map, with nothing to install and no data leaving your machine. It is fair to say that the version installed on your machine and the online one do not name the axes the same way. Installed on your machine, Standpoint uses the small distilled model described above. In the browser, the page carries an even lighter model, which compares words by meaning. It only loads a real language model if you ask it to fill the empty cells.

Taken on its own, not one of these pieces is impressive. A computation Pearson did by hand in 1901. A pocket model that can do nothing but its three small tasks. A drawing with no library. A table format anyone can type. A browser tab. The whole interest is in the assembly: each piece passes to the next exactly what it cannot do itself. The arithmetic to the arithmetic, the words to the model, the strokes to the SVG. Nothing, at the end, has been guessed.

It is precisely because every piece is small that the whole thing fits in a tab. Your notes on your competitors stay with you, not because a contract promises it, but because there is no server at the other end. Gartner puts a year of interviews and teams of analysts into placing a market. Standpoint has no such ambition, granted. But it runs inside the page you are reading, and everything in it checks out row by row.

Conclusion

An honest table deserves better than a gut reading. The map does not replace the table: it gives the overview, the one that tells you which rows to reread closely. And since the axes stay blends of your own criteria, the map holds up in a meeting. Every position traces back to the original figures, kept in the output YAML file.

The fastest way to form an opinion is to try it: deraison.ai/standpoint runs the engine in your browser, with no install and no upload.

Standpoint is also open source under the BSD license: pip install standpoint, then one command on your CSV. The code, the examples and the documentation live at github.com/warith-harchaoui/standpoint. Bring a table; leave knowing where you stand.