You want to make a folding chair people will take camping. It needs to be comfortable enough to sit in and small enough to carry. Before setting up a production line, you build one.
The workbench is covered in parts. You try a hinge, fold the frame and find that the legs catch. Move the hinge. Try again. Then someone sits in it and tells you the seat is too low. A pencil mark changes the next version.
Those are useful discoveries while the design is still on the bench. On a production line, the same change could mean adjusting the equipment and reworking a batch of chairs.
Data teams often start with the production line. Suppose a support lead needs to decide which team needs help with its backlog. Before anyone has shown a useful answer, the request becomes a pipeline, a warehouse table and a refresh schedule. We're arranging to manufacture the answer before we've tried using it.
A laptop, an analytical engine and an agent can give that question a workbench. We can inspect the material, try a model and put a rough result in front of the person who needs it. The first job is discovering which answer is worth repeating.
Why the factory came first
A factory makes sense when people need the same product made dependably. The measurements are settled, the stations have defined jobs and a new worker can follow the process without asking the designer about every cut.
Shared data platforms brought similar advantages. They collected records from operational systems, prepared common tables and gave reports a dependable place to run. Work that outgrew a desktop had somewhere to go. Broad analysis could run away from the application serving customers, which is the distinction in Before You Point an Agent at Your Data.
Building that preparation took effort. Once a team had connected the sources and worked out the relationships, running the process again was valuable. Shared definitions and checks made the next report easier to trust.
The habit was to begin there. A new question arrived, and the team started arranging the collection, transformations and schedule. Sometimes the result became a useful service. Sometimes the question changed halfway through, after the line had already been built around the first version.
Getting data into a shared warehouse can mean connecting sources, arranging ingestion, cleaning and joining records, shaping them into a common model, and setting up schedules, access and checks. All of that has a purpose when people depend on the result. But if we're still figuring out what the support lead actually needs, we're committing to the production process before we've settled the design. On a laptop, we can work through many of those same questions with a local copy, changing the model as we learn without rebuilding a recurring pipeline.
The workbench gives that uncertainty somewhere cheaper to go.
Both spaces need sound measurements. The factory adds a repeatable operating process; it can be a small managed service. Keep the bench available for the next design.
The power tools fit on the bench
A workbench becomes more useful when the tools can handle the material in front of you. You can try a design without needing a factory machine for every operation.
DuckDB gives me that kind of analytical tool. In the local setup, it runs inside the program using it and can query CSV, JSON and Parquet files without a separate database server. The files can stay ready for another attempt while the query changes. For supported operations, it can also work beyond available memory by using disk, although the data, query and machine still set the limits.
The DuckDB team ran all 22 TPC-H benchmark queries in about 47 minutes on battery power. The dataset represented about 3 TB in CSV form. They generated it as Parquet and loaded it into DuckDB before querying. Their Framework laptop had 128 GB of memory and 8 TB of storage: a capable bench, rather than a promise about every laptop. The experiment and its setup
An agent changes how quickly I can use those tools. It can inspect the files, write a query, read the result and try another approach. I still choose the question and judge whether the result means what we think it means. More attempts help when they are easy to inspect and revise.
The next query against a local copy uses my machine's compute. It doesn't add a cloud query charge or take a slice of a shared reporting platform's capacity. The machine, extraction work and agent calls still have costs. Cloud pricing varies too; the useful comparison is what repeated exploration consumes in the environment available to you.
I can try answering the question before committing to keeping its answer ready every morning.
Measure before you cut
The carpenter still measures on the workbench. Cheap wood and a fast saw make a wrong cut easier to repeat. The dimensions have to mean something before the parts can fit.
Most of my new data work starts with a new API, a folder of downloaded datasets, or the exports and spreadsheets that arrive with a new question. I pull a representative copy onto my laptop and let the agent inspect it in DuckDB. Which fields are populated? What does one record represent? Which identifiers repeat? Where is the useful information buried inside the JSON?
I choose the copy and the agent's access to suit the data. Local query execution tells us where the calculation runs; the agent's tools and model determine what information may be sent elsewhere. That needs deciding before handing it the files.
Then the parts start coming together. The agent tries joining the new data to datasets I already have. Some keys match. Some mean something different from what their names suggest. Some joins duplicate rows until a count no longer adds up. It revises the mapping and runs the checks again.
For the illustrative backlog question, a ticket might have several status updates. Treat every update as another ticket and one busy case can become a whole queue on the chart. The model needs to establish which record describes a ticket's current state and how it connects to the responsible team.
Those are modeling decisions made while the design is easy to change. For the current-state view, check that every ticket in the chosen source snapshot appears once, its responsible team matches the source, and the backlog uses a recorded as-of time. The agent can rerun those checks after each query change. A query that runs successfully has only made a cut; the next check tells us whether the piece fits.
This is the working environment I described in Give the Agent a Working Environment: chosen tools, a clear target and feedback the agent can inspect. Here, its job is to learn what the eventual process needs to do.
Let someone sit in the chair
Eventually, someone has to fold the chair, carry it and sit in it. The drawing can look convincing while the armrest catches your elbow every time you get up.
Once the data holds together, I use a small FastAPI service to query DuckDB and put a rough dashboard on top. That gives someone a way to try the answer: change the filter, inspect a group and follow the result back to its records.
For our support lead, a chart of ticket counts may be less useful than a view of how long unresolved work has been waiting. They might point out that some tickets are waiting on customers, while others are ready for the team to act. That distinction changes the staffing decision and the data the view needs.
The query can run, pass the ticket checks and still answer a less useful question. Trying the dashboard with the lead tests that last part. Discovering the missing distinction now means changing a query and a screen, before a recurring pipeline is built around the wrong measure.
A sample can expose a broken join or an awkward view. A staffing decision needs coverage of the queues and dates being considered. The result should make its scope and collection time clear, and the checks should include enough real cases to establish that the categories mean what their users expect.
The payoff is a useful answer, or a better question. Sometimes the lead gets what they need for this decision and the work ends there. We built the chair we needed. There are no orders for another hundred.
Send the drawings with it
If someone else is going to make the chair, they need more than the finished example. They need the dimensions, the parts list and the details that stopped the hinge from catching. Otherwise they get to rediscover the same mistakes.
The data work needs a similar handoff. Keep the source references and collection dates, the model, the queries and the checks that caught bad joins. Keep the definition of the measure and the feedback that made the dashboard useful. There should be a way to run the work again without reconstructing the session from memory.
An agent can help package that into scripts and a small project. A second run against the retained inputs checks whether the process produces the same result. A run against a new extract checks something different: whether the assumptions still hold as the source changes. Both are useful before people depend on it.
Open files such as Parquet make the material reusable. Definitions and checks carry the design forward. Moving queries into another engine can still require changes, so the target process needs to be checked against the expected results. A good handoff preserves what was learned while allowing the equipment to change.
That package is valuable even if the analysis runs only once. It explains how the answer was made and gives the next question a place to start.
When the orders keep coming
Now imagine people are ordering the chair. They expect the next one to fold the same way, and they expect delivery while the original designer is away. The factory earns its place by making that promise repeatable.
The backlog view earns shared delivery when people depend on the result being available, correct and current without its builder standing beside the machine. That promise needs agreed definitions, controlled access, a suitable refresh schedule and someone who notices and responds when the process fails.
A process on my laptop can support experiments and sharing. Depending on my open laptop and my recollection of the steps is a poor service promise. What needs improving is the operating arrangement: where the work runs, how it repeats and who responds when it stops.
The answer could be a small shared service with a scheduled job. It could use an existing warehouse or lakehouse. DuckDB could remain part of the solution. Choose enough infrastructure to meet the demonstrated workload and responsibilities; a factory can have one well-organized production line.
The measurements from the bench become checks on that line. Did the source arrive? Do the identifiers still match? Did the join multiply the ticket count? A supplier sending the wrong-sized part should be noticed before a whole batch is assembled from it. A failed check needs an owner and an outcome people can understand.
The schedule should follow the decision too. A saved analysis run when someone asks may be sufficient. If the team needs a dependable view ready before Monday's meeting, prepare it with time to detect and repair a failed refresh. Selected live checks may serve details that change later, as in Data on Demand or Always On.
The wider responsibilities of operating that service belong to From Prototype to Production. Here, the first challenge is discovering the definition, scope and result that deserve dependable delivery.
Keep a bench beside the line
Opening the factory gives the workbench another job. The next chair design can be tried there while the line keeps making the version customers ordered. A new hinge gets tested before every station is adjusted around it.
Data work can follow the same loop. Try a new source or measure, check the relationships and let someone use the result. When the change earns its place, carry the tested definition and checks into the shared process.
My laptop is a practical place to do that work. An existing platform may already offer a suitable place to experiment too. The point is to keep discovery easy to change while dependable delivery gets the operating process it needs.
Build a chair worth using. Then build the line the orders require.


