Contributor Setup: From Login to First Pull Request
STACKIT
Last updated on
Start in the browser in minutes. Or set up a laptop or a VM for the full local preview, then open your first pull request.
What you know can help the next person take a step. You turn it into an asset, which is one page, or into a trail, which is a path through pages that already exist. Organisations also have a profile, so readers see who stands behind the work.


Three ways lead to the same page. The SCF Studio is the easiest start and checks every field while you type. On a laptop or VM you can also write the MDX file in your editor, with AI help from Cline.
Look in the explorer first. Maybe a page already covers half of it and you improve that one. The Studio also shows similar entries before you write.


In the browser you write in the Studio on the dev site. It opens with your STACKIT login. On a laptop or the VM you write in the Studio or in your editor.
STACKIT
The sovereign European cloud provider behind the framework, delivering IaaS and PaaS from its own data centers in Germany and Austria.
No Docker on your laptop? Then install nothing here. Create the token in the next sections, fork and clone, then go on with Work on a VM Instead of Your Laptop.
Install these three, in any order:
Nothing else gets installed. No Node, no pnpm, no build tools on your host.
STACKIT
The sovereign European cloud provider behind the framework, delivering IaaS and PaaS from its own data centers in Germany and Austria.
Your laptop has only 8 GB, or you may not install Docker Desktop or podman? Then let a small VM in your own STACKIT project run the dev container. VS Code on your laptop connects to it. Your site still opens at http://localhost:4321.
On your laptop you need:
Create the VM. In your clone on the laptop run .devcontainer/vm/scf-vm-create. It first asks which addresses may connect by SSH. At home, take the address it suggests. In a company network, ask your IT for the range. Then it shows what it creates and what that costs. It asks once more before it starts. The VM is ready after about two minutes.
Set it up. The script offers to run scf-vm-setup on the VM. It asks for your username and your token, checks both, clones your fork and downloads the dev container. This takes about three minutes, most of it the download. It also asks whether to protect your tokens with a passphrase. Say yes, see below.
Connect. In VS Code run Remote-SSH: Connect to Host and choose cloud-framework-vm. If VS Code asks for the platform, choose Linux. Open the folder /home/ubuntu/scf-content and confirm that you trust it.
Open the container. With protected tokens, first run scf-vm-unlock in a terminal on the VM. Then choose Reopen in Container. Then run hike in the terminal. The first start of the container takes longer. After that hike is ready in about 20 seconds.
What it costs, at STACKIT list prices for region eu01 without VAT (October 2026):
| How you use it | Cost |
|---|---|
| Per hour while it runs | about 0.24 € |
| 8 hours on 20 days, deallocated in between | about 73 € |
| 4 hours a week | about 39 € |
| Deallocated all month | about 35 € |
| Never switched off | about 208 € |
The deallocated row is the fast disk and the public address. Both keep running, the VM does not.
Anyone with rights on your STACKIT project can copy the disk of your VM. A token in a plain file travels with that copy. Protected, your STACKIT Git token and your STACKIT AI token are encrypted on the disk. Readable copies only exist in memory while you are logged in.
y when scf-vm-setup asks. Pick a passphrase and keep it in your password manager. You can run scf-vm-setup again later to turn it on. Then rebuild the container once.scf-vm-unlock. It asks for the passphrase and pulls a newer dev container image if there is one.ai --setup. Then run scf-vm-save on the VM, so it is stored encrypted.--stop locks the tokens again. scf-vm-lock does it right away.scf-vm-setup --new-token and enter your AI token again with ai --setup.The script, the VM template and a short README live in the content repository under .devcontainer/vm . Nothing is loaded from the web and run.
A STACKIT account is all the browser path needs. For a laptop add Docker Desktop or podman, VS Code, git and one access token. Everything else, from Node to the test browser, already sits inside the prebuilt image.
Three things. Only the first two touch your machine:
A STACKIT account. It is the identity you log in with. It onboards you automatically.
A container runtime, an editor and git. Docker Desktop or podman, plus Visual Studio Code with the Dev Containers extension, plus git to clone your fork. No room for it on your laptop? A small VM in your own STACKIT project does the job, see Work on a VM Instead of Your Laptop.
An access token from the Git instance, which you create in a later step and use as your password for both cloning and pulling the image.
You never need access to the application repository. Everything the site needs to build, Node, the docs app, the diagram toolchain and the test browser, is already inside the image.
If you do not have a STACKIT login yet, create one first at accounts.stackit.cloud , then come back to the next step.
Use a personal work address for it, in the form firstname.lastname@company.com. The Git instance builds your username from the part before the @. You cannot change that username later.
If the login works but the Git instance rejects you afterwards, your account is probably not in the STACKIT organization that hosts the instance. Contact Framework Core and we will sort it out.
Log in once with the STACKIT login, the same one you use on portal.stackit.cloud. That creates your Git user. A pipeline then adds you to the contributors team within 15 minutes. Nobody has to invite you.
Log in once with the STACKIT login, the same one you use on portal.stackit.cloud, at scf-content.git.onstackit.cloud . That single login does two things:
@, so with a personal address it reads firstname.lastname.Contributing here is public. Your name appears once you declare it in a short form. Until the first daily mirror your username shows. After that, without a declaration, the credit reads Name not public. Pseudonyms and initials work too.
Contributing here is public. The site credits people by name in two places: the history timeline on every asset and trail plus the Maintainers block on the pages you are listed for. That is the point of the credit. You decide which name it is.
Three separate sources feed it:
| Where | Comes from | You change it in |
|---|---|---|
| History timeline | the author of your commits, shown as who and when | git config user.name in your clone |
| Maintainers credit | the Full name of your STACKIT Git profile, mirrored daily once you have declared it | your Git profile |
| The profile panel that opens on hover | your biography, website, address and contribution record | your Git profile, once you have declared them |
Your commit messages never appear on the site. The timeline names the author and the date and nothing else, because a commit message is written for the repository rather than for a reader.
Nothing is shown until you release it yourself, your name included. You do that once, in a declaration: open an issue in the content repository with the Contributor declaration template and tick the details you want shown. A pipeline turns it into a proposed change of docs/settings/contributor-members.json, which Framework Core or your framework owner approves. That file is the only place the site reads it from. You cannot edit that file yourself. That is deliberate.
Until the first daily mirror your username shows. After that, without a declaration recorded there, the daily pipeline publishes nothing about you, so a maintainer credit reads “Name not public”. Your commits still carry your name inside the repository, as they do in any repository, but the website does not repeat it. A detail you did not release is not merely hidden: it is never fetched from your profile and never written down anywhere. Writing role: true next to your name in an asset does nothing either. Only the person a field describes can release it. A content file is not that person.
Two details are worth knowing before you tick the boxes. Your address only appears if you also made it public in your Git profile, because otherwise the API hands out a no-reply placeholder, which is not a contact. Your contribution record is matched through the address on your commits, so it counts the commits you author under your own account. To change any of it later, file a new declaration. To withdraw everything, pick the Withdraw your declaration template.
A pseudonym, a short form or just your initials are all fine in either place. Emptying the Full name works too: after the next mirroring run the maintainers credit shows “Name not public”, it never falls back to your username. If you would rather not have your private address in the commit history, set a no-reply identity in the same breath:
git config user.name "Your display name"git config user.email "your-username@noreply.scf-content.git.onstackit.cloud"Your address is never shown unless you ask for it: it appears only when a page lists it explicitly, or when you released it in your declaration and made it public in your Git profile.
Open the SCF Studio at https://dev.framework.stackit.cloud/studio/ and sign in with your STACKIT Git account. The dev site lets you in once the pipeline has added you to the contributors team. The studio opens the pull request for you. From here on, skip the steps marked Laptop or VM.
STACKIT
The sovereign European cloud provider behind the framework, delivering IaaS and PaaS from its own data centers in Germany and Austria.
No Docker on your laptop? Then install nothing here. Create the token in the next sections, fork and clone, then go on with Work on a VM Instead of Your Laptop.
Install these three, in any order:
Nothing else gets installed. No Node, no pnpm, no build tools on your host.
STACKIT
The sovereign European cloud provider behind the framework, delivering IaaS and PaaS from its own data centers in Germany and Austria.
With Docker Desktop you skip this section.
Point VS Code at podman. Open the settings (Ctrl + ,, on the Mac ⌘ + ,), search for dev containers path, change Dev > Containers: Docker Path from docker to podman, then restart VS Code. Without it the extension looks for a docker binary that is not there and the container never starts.
Give the machine memory and disk. The build and the test suite run inside the podman machine and the default one is too small for them. Set it up with room from the start:
podman machine init --memory 8192 --cpus 4 --disk-size 60podman machine startIf your machine already exists, adjust it afterwards:
podman machine stoppodman machine set --memory 8192 --cpus 4podman machine startSTACKIT
The sovereign European cloud provider behind the framework, delivering IaaS and PaaS from its own data centers in Germany and Austria.
On Windows, do all of this inside WSL2 and clone into the Linux file system, for example ~/projects/scf-content.
A clone under /mnt/c/... looks like it works: the container starts, the site builds, the page loads. But file change events do not cross the Windows to Linux boundary reliably, so hot reload never fires and your edits appear to have no effect until you restart the server.
Laptop and VM only. Create it on the Git instance under Settings, Applications. It is your password for the clone and for the image. It is shown exactly once, so save it in your password manager. Set the access dropdown to All, because a token with Public only access fails with 403 even when every right looks correct.


On the Git instance, open Settings, then Applications, then Generate new token. Grant exactly these permissions:
| Permission | Level | Needed for |
|---|---|---|
repository | Read and Write | cloning the content repo, pushing branches |
package | Read | pulling the prebuilt dev container image |
user | Read | scf-tea, which asks who you are first |
issue | Read and Write | opening an issue from the command line |
Above the permission list sits a dropdown called Repository and Organization Access. Leave it on All (public, private and limited). On “Public only” the token cannot see the private content repository at all. Cloning as well as the registry login fail with a 403 even though every permission above is set correctly.
Laptop only. Log in with your Git username and the token as the password, then pull the image. Run this in a terminal on your computer. Inside the container there is no docker or podman.


Log in with your Git username and the token as the password, then pull the image:
docker login scf-content.git.onstackit.clouddocker image pull scf-content.git.onstackit.cloud/scf-core/scf-system:latestpodman is a drop-in replacement here: podman login and podman image pull take exactly the same arguments.
Pulling the image up front is optional, VS Code pulls it for you on the first container start. Doing it manually just makes the first start faster and shows you early whether the login worked.
The image is multi-arch: the same pull gives Intel and Windows machines the amd64 variant and Apple Silicon Macs the native arm64 variant, automatically. When you pull a newer image later, follow it with Rebuild Container in VS Code, because a plain reopen keeps the cached old container running. Superseded image versions pile up as untagged leftovers, so run docker image prune (or podman image prune) on your machine now and then to clear them out.
Laptop and VM only. Fork the shared repository, clone your fork and add the shared one as upstream for updates. On Windows, clone inside WSL2, never under /mnt/c. The VM script runs from this clone too. On a laptop, then choose Reopen in Container.


The content repository grants read access only, so your fork is the place you push to. Everybody works this way, Framework Core included. Open scf-core/scf-content and press Fork, then clone your copy with your Git username and the token as credentials:
git clone https://scf-content.git.onstackit.cloud/<your-username>/scf-content.gitcd scf-contentgit remote add upstream https://scf-content.git.onstackit.cloud/scf-core/scf-content.gitThe upstream remote is how you pull later changes from the shared repository into your fork.
One thing to know before you branch: your fork copies every branch this repository has on the day you fork it, half-finished ones included. Start new work from upstream/main and from nothing else, which is also why a fork that has fallen behind cannot get in your way. When you do want it up to date, your fork’s page shows a green banner with a button that does it in one click. On our instance that button still carries its untranslated label repo.sync_fork.button, so go by the green banner rather than by the wording. A branch you have kept for weeks wants main merged into it before you open the next pull request.
Open the folder in VS Code. It detects the dev container configuration and offers Reopen in Container, which is also available from the command palette. The first start pulls the image and takes a few minutes; every later start is quick.
Your clone is mounted into the prebuilt app as its content, which is why you can preview the complete site without ever touching the application repository.
VM only. Needs the STACKIT CLI with your project set. About 0.24 € per hour while it runs.


Username and token are checked before anything is cloned. The script also offers to protect your tokens with a passphrase. Say yes.


Connect to cloud-framework-vm with Remote-SSH. With protected tokens, run scf-vm-unlock in a terminal on the VM first. Open /home/ubuntu/scf-content and choose Reopen in Container. Pointing the Docker on your laptop at the VM does not work.
Your laptop has only 8 GB, or you may not install Docker Desktop or podman? Then let a small VM in your own STACKIT project run the dev container. VS Code on your laptop connects to it. Your site still opens at http://localhost:4321.
On your laptop you need:
Create the VM. In your clone on the laptop run .devcontainer/vm/scf-vm-create. It first asks which addresses may connect by SSH. At home, take the address it suggests. In a company network, ask your IT for the range. Then it shows what it creates and what that costs. It asks once more before it starts. The VM is ready after about two minutes.
Set it up. The script offers to run scf-vm-setup on the VM. It asks for your username and your token, checks both, clones your fork and downloads the dev container. This takes about three minutes, most of it the download. It also asks whether to protect your tokens with a passphrase. Say yes, see below.
Connect. In VS Code run Remote-SSH: Connect to Host and choose cloud-framework-vm. If VS Code asks for the platform, choose Linux. Open the folder /home/ubuntu/scf-content and confirm that you trust it.
Open the container. With protected tokens, first run scf-vm-unlock in a terminal on the VM. Then choose Reopen in Container. Then run hike in the terminal. The first start of the container takes longer. After that hike is ready in about 20 seconds.
What it costs, at STACKIT list prices for region eu01 without VAT (October 2026):
| How you use it | Cost |
|---|---|
| Per hour while it runs | about 0.24 € |
| 8 hours on 20 days, deallocated in between | about 73 € |
| 4 hours a week | about 39 € |
| Deallocated all month | about 35 € |
| Never switched off | about 208 € |
The deallocated row is the fast disk and the public address. Both keep running, the VM does not.
Anyone with rights on your STACKIT project can copy the disk of your VM. A token in a plain file travels with that copy. Protected, your STACKIT Git token and your STACKIT AI token are encrypted on the disk. Readable copies only exist in memory while you are logged in.
y when scf-vm-setup asks. Pick a passphrase and keep it in your password manager. You can run scf-vm-setup again later to turn it on. Then rebuild the container once.scf-vm-unlock. It asks for the passphrase and pulls a newer dev container image if there is one.ai --setup. Then run scf-vm-save on the VM, so it is stored encrypted.--stop locks the tokens again. scf-vm-lock does it right away.scf-vm-setup --new-token and enter your AI token again with ai --setup.The script, the VM template and a short README live in the content repository under .devcontainer/vm . Nothing is loaded from the web and run.
Laptop and VM only. Run hike in the container terminal. The real site opens on localhost:4321 with the components your readers see. Every save shows up within a second. Type help for the other tools.


In the container terminal, run:
hikeThe same thing is available as the VS Code task 🥾 Hike, Start Dev Docs. The site is forwarded to http://localhost:4321 with hot reload, so every save shows up in the browser within a second.
Type help to see the full tool belt:
| Command | What it does |
|---|---|
hike | dev server with hot reload on http://localhost:4321 |
summit | full production build |
panorama | serve the built site |
patrol | build plus the complete UI test suite, the same gate as your PR |
scout | how to update the dev container image |
Laptop and VM only. In your container the SCF Studio runs next to the site you preview with hike. Open a file you wrote and the studio loads it, so you change only what you edit. It writes frontmatter that already satisfies the pipeline rules.


Branch off upstream/main rather than off your own main, then write:
git fetch upstreamgit switch -c content/short-description upstream/mainYour fork’s main falls behind the moment somebody else contributes. A branch started on top of it drags that gap into your pull request. Fetching first costs a second and takes the question away entirely. When you do want the fork itself tidy, CONTRIBUTING has the commands for that.
For new pages, use the studios instead of copying frontmatter by hand:
http://localhost:4321/studio, writes a contributor profile, an asset, a trail or a framework page. It also loads an existing file and changes only what you edit, so everything you leave alone stays exactly as it was.http://localhost:4321/diagrambuilder, draws a diagram in the SCF design and saves it next to your page.Both run on your local dev server. The SCF Studio runs on the dev site as well. It writes frontmatter that already satisfies the pipeline’s rules: a real description in the rewarded 120 to 160 character window, a category from the allowed list and at most 10 tags.
The quickest way in needs no setup at all. Open the SCF Studio on the dev site and sign in with your STACKIT Git account. The studio creates the branch and opens the pull request for you. There is nothing to install. The dev site has its own login, which you ask for once by writing to framework@stackit.cloud. The studio lives at https://dev.framework.stackit.cloud/studio/.
For the authoring rules behind the generated files, see the asset integration guide and the trail setup guide.
Laptop and VM only. Run it in the container terminal. Cline uses Qwen3.8, which did best in our own tests for this work.


In the VS Code terminal of the container run:
ai --setupIt first explains what the assistant does: it drafts an asset or a trail from a few sentences of yours, knows the authoring rules and explains a red patrol. Nothing is written without your click. Then it shows how to get a token for STACKIT AI Model Serving from your own STACKIT project. The STACKIT guide to the shared models has the steps. Last, it checks the token, stores it next to your Git token and sets up Cline in VS Code with a STACKIT model. You do not click through any settings. Open Cline with its icon in the left bar.
Ask it in plain words, the way you would ask a colleague. A few things it does well here:
llms.txt and AGENTS.md in your clone and lists what does not fit.assetId and anchors.Read every change before you accept it. Cline shows each one and writes nothing without your click.
You can say no and run ai --setup again later. Usage is billed to your STACKIT project. Cline runs on Qwen3.8: we benchmarked the shared models for this kind of work. It came out best.
Laptop and VM only. patrol runs locally what the pipeline runs: the build, the UI tests and a walkthrough of everything you changed. A few minutes here save a review round.


patrolpatrol reproduces what the pipeline runs: the production build, the UI test suite and a walkthrough of every asset, trail and profile your branch touched. It takes two to three minutes and saves you a review round, because a green patrol almost always means a green pull request.
The studio opens the pull request for you, or you push your branch and open it yourself. The checks run in the background. Tick the preview box and a password-protected preview site goes up for the review. Tick the merge box and the merge follows the approval.
Push your branch to your fork. Then create the pull request with scf-tea in the container terminal. Do not use the web interface: scf-tea fills in the current template and asks for the required confirmations. Before your first pull request, run scf-tea-login once and give it your access token.
scf-tea pr create \ --base main \ --head <your-username>:content/short-description \ --title "Add network guidance" \ --description "Adds network guidance for the migration framework." \ --auto-mergescf-tea asks you to confirm three points:
A separate check reads them from the description and stays red until all three are ticked. So keep the prefilled text in place. scf-tea pr create --help lists every option, --preview and --confirm-all among them.
The pipeline then checks your pull request. Most checks look only at the files it touches:
docs/ and the guides in the repository root.category, at most 10 tags of at most 20 characters, a maintainer. A missing description, one under 90 characters or a placeholder stops the pull request. 120 to 160 characters earn a ranking bonus.<LinkCard> or <LinkChip>. Its target on the site exists. See the asset integration guide.docs.stackit.cloud still work. Other dead links are only reported. This check runs across the whole repository.#anchor.Did a check stop your pull request? You do not need to read the job log. The pipeline writes a comment that names the check, the file and what to change. After the checks it builds the full site, runs the UI tests and posts a report on your pull request.
A temporary preview site is optional. Pass --preview or tick the preview box. Your pages go up within fifteen minutes of the checks turning green. The preview follows every push and disappears when the pull request closes. It has its own username and password: mention @scf-core/Framework-Owner in your pull request and you get them in private. Never post a password in a comment, an issue or a file. Nothing depends on the preview, because patrol shows you the same result locally.
Automatic merge is the normal way. With --auto-merge or the ticked box, your pull request merges by itself as soon as Framework Core or a framework owner approves and every check is green. A job looks every ten minutes. This works for pull requests that change only files under docs/. Without the box nothing is blocked: Framework Core merges for you, which can take longer. The review decides on formal grounds only. Either way your content goes live with the next site deployment, which runs every two hours.
VM only. --stop deallocates: CPU and memory go back, disk and address stay. About 35 € a month. Logging out or --stop locks protected tokens again.


Setup is a one-off. Authoring is the part you will come back to. The onboarding journey walks through registering your contributor profile, the asset frontmatter schema and chaining your assets into a trail of your own.