Every step in Tines 3B runs as its own container image, defined by a Dockerfile that lives in the step alongside your code. The easiest way to change that image is to ask Tines 3B in chat: describe what the step's environment needs, and Tines 3B edits the Dockerfile, rebuilds the step, and checks that it still works. You can also edit the file yourself. Either way, Tines 3B does the building and running for you.
This article explains how Tines 3B uses the Dockerfile, how to change it by prompting, and what to expect when you do.
Every step is a small container image
A step is more than a snippet of code. It's a container image described by a Dockerfile, next to your source, in whatever language the step uses. You don't build or run containers yourself. When a step runs, Tines 3B works in two phases:
Build. Tines 3B turns the Dockerfile into a runnable image, one layer at a time.
Run. Tines 3B executes the step's command inside a fresh, single-use container built from that image.
Splitting the work this way keeps steps fast. Builds are cached, so the slow setup happens once and later runs skip straight to executing. It also means each step brings its own environment: one step can run Python with a data library while the next runs a shell script, and neither has to agree with the other about what's installed.
Just ask Tines 3B
You don't have to write Dockerfile instructions yourself. Tell Tines 3B what the step's environment needs, in plain language, and it does the work. For example, you can ask:
"Add the
ffmpegsystem package to this step.""Switch this step to Python 3.12."
"This step needs the
libxml2library installed.""Give this step a durable
/storagevolume calledcache."
Tines 3B edits the step's Dockerfile for you, reruns the step to rebuild the image, and confirms the change works. It follows the same build rules described below, so you get a correct Dockerfile without having to remember the details. If something can't be done, or there's a better way (like declaring a package instead of installing it by hand), Tines 3B will tell you.
View the Dockerfile anytime
You can always see what the Dockerfile currently holds. Open the step, and the files panel lists the Dockerfile next to your code. The panel is a read-only view, so you read and inspect the file here rather than type into it. A few things it's handy for:
See the current image. Check which base image and packages the step builds from.
Review what changed. Turn on the diff view (⌘⇧D) to see Tines 3B's edits against the previous version.
Point Tines 3B at a line. Select a span of the Dockerfile and reference it in chat, so your request is precise.
When you want a change, describe it to Tines 3B and it does the editing.
What you start from
When you create a step from a template, it already has a working Dockerfile, so neither you nor Tines 3B starts from a blank file. The templates begin from a versioned, public base image and then use ordinary Dockerfile instructions. For example, the current templates start from these base images:
TypeScript and React.
oven/bun:1.4.4.Python.
python:3.13-slim.Shell.
debian:13-slim.
A typical template installs a few system tools, copies your code in, and ends with the command that runs the step. Here's the shell template's Dockerfile:
FROM debian:13-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends curl jq sqlite3 && \
rm -rf /var/lib/apt/lists/* /var/log/apt /var/log/dpkg.log
/var/cache/ldconfig/aux-cache
COPY --link . .
CMD ["sh", "./script.sh"]
When you ask for a change, Tines 3B builds on this foundation rather than rewriting it from scratch.
What can change
The Dockerfile understands the instructions you'd expect, and a few rules shape how Tines 3B reads them. These are the things you can ask for, or write yourself:
`FROM`. Sets the base image. The Dockerfile must start with
FROM(a single leadingARGis allowed before it).`RUN`. Runs a command during the build, for example to install a system package.
`COPY` and `ADD`. Bring files into the image from the step's own folder.
`CMD`. Sets the command Tines 3B runs when the step executes.
`VOLUME`. Mounts durable storage under
/storage, which persists across runs.
Multi-stage builds, with more than one FROM, are supported. Only the final stage describes the step that runs, so earlier stages are used to compile or prepare artifacts and then dropped from the runtime image. Any VOLUME instruction belongs in that final stage.
Declare dependencies in the manifest, not by hand
When a step needs an npm or Python package, it goes in the step's manifest rather than an install command in the Dockerfile. Ask for "add the requests package" and Tines 3B updates the right file:
npm packages. Listed in
package.json(TypeScript and React steps).Python packages. Listed in
requirements.txtorpyproject.toml.
The template's existing install layer picks them up and installs them when the step builds, and Tines 3B caches that layer so the packages are fetched once and reused. Listing dependencies in the manifest also keeps them honest: Tines 3B reads these files across your live workflows to build an always-current inventory of the outside code you're running. Base images named in your FROM lines are tracked the same way.
How builds are cached
Tines 3B names each step's image from a hash of the files it builds from: the Dockerfile and your source, but not the step's tests/ directory. Change any of those files and Tines 3B rebuilds; leave them unchanged and it reuses the image it already has. Editing a test never busts the build cache.
A couple of limits are worth knowing:
The build context is the step's own folder. A step builds only from its own directory, so it can't
COPYfiles from the workflow root or another step. A shared helper has to be copied into each step that uses it.The context is capped at 1,024 files, and a step with no
Dockerfilecan't build at all.
To speed up repeated installs, a RUN step can use a cache mount, for example RUN --mount=type=cache,target=node_modules .... The cache target must be a single workdir-relative name made of letters, digits, ., _, or -, like node_modules or bun, not a full filesystem path. To add npm packages, edit package.json so the template's existing install layer caches them for you.
What the build can and can't reach
The build prepares the step's image; it isn't the step running. So a build can't use the things that belong to execution: workflow route URLs, connectors, and volumes aren't available at build time. If a build check needs an environment value or a storage fixture, supply it in the build itself.
Reaching the network during a build depends on what the Dockerfile asks for. Tines 3B already bundles the default templates' toolchains, package installs, apt layers, and base images, so an unmodified TypeScript, Python, React, agent, or shell step builds with nothing to fetch. Tines 3B only reaches out when the Dockerfile asks for something new, such as a different base image or tag, or an extra npm, Python, or apt package, which it fetches from that package or image's source during the build.
In short
The Dockerfile is your step's environment, and inside Tines 3B you change it by telling it what you need. It edits the Dockerfile, rebuilds the step, and checks the result, following the rules above. You can open the files panel anytime to view the current Dockerfile, see what changed, and point Tines 3B at specific lines. Either way, Tines 3B builds the image once, caches it, and runs your command inside a fresh container every time the step fires.
