1. LandOffer
  2. Blog
  3. All articles
  4. Hugging Face Spaces Portfolio: Choose Public, Protected, or Private Before Sharing

Job search

Hugging Face Spaces Portfolio: Choose Public, Protected, or Private Before Sharing

Nine current official sources and two completed original fictional assets distinguish repository from runtime access, creation eligibility from hardware cost, and a proposed demo route from actual visitor acceptance.

10 min readLandOffer team

Choose a Hugging Face Space's visibility for both the repository and the running app. Public exposes the code and demo; Protected hides the repository while leaving the app publicly accessible; Private limits both to the owner and collaborators. For a portfolio, the right choice depends on what you can share and what the reviewer needs to inspect. Protected is not a private-demo setting.

This guide reviews official documentation inspected October 20, 2026, with original fictional decisions and visitor scenarios. We did not deploy or create a Space, log in, upload files, add secrets, change visibility, or test a private application. You can browse recent roles on LandOffer.ai to identify the engineering evidence worth presenting, then choose a sharing route that matches your actual permissions.

A visitor can use a demonstration at an open workshop window while its blueprint cabinet remains closed.

Separate repository access from runtime access

The official Spaces overview gives this visibility distinction:

Visibility Source repository Running app for an outside visitor Can others clone the repository?
Public Public Public Yes
Protected Owner and collaborators Public through the embed URL or configured custom domain No
Private Owner and collaborators Owner and collaborators No

The important portfolio question is what a reader can examine. A reviewer may be able to try the demo without reading its code, or read code without confirming that the app currently runs. If the reviewer needs both, assess both separately.

Repository settings places Protected visibility within PRO or Team and Enterprise plans. Private repositories are absent from other users' searches and return a not-found response to unauthorized visitors. Sending a private link does not create access for its recipient.

Review the material and the intended visitor before choosing the visibility label. If your project is meant to demonstrate readable code and reproducibility, hiding the repository can remove evidence you wanted an interviewer to see. If the app should not be public, hiding only the source does not meet that requirement.

Check plan eligibility separately from hardware cost

The current hardware guide lists CPU Basic with two virtual CPUs, 16 GB memory, 50 GB disk, and no hourly hardware charge. It also explicitly says new Gradio or Docker compute Spaces require a paid plan; Static Spaces remain free. “Free hardware” therefore does not mean unrestricted free creation of every kind of Space.

There is a narrower exception in the overview for free personal accounts in good standing hosting up to two Gradio Spaces on ZeroGPU. Do not extend that exception to arbitrary Docker apps or assume that your account qualifies.

The Python management guide gives further context: CPU Basic compute creation requires a subscription, while paid hardware requires billing with a payment method and prepaid credits. Check the current combination you intend to use rather than applying an old tutorial's free-tier description. We did not enter a creation or checkout flow.

The pricing page separates subscription benefits and hardware rates. A protected-code preference, paid compute, and persistent storage are distinct needs; do not assume that buying one removes every other cost or access constraint. No upgrade is necessary just to prepare the portfolio evidence discussed below.

Review what your app actually exposes

A visibility choice does not grant permission to publish employer code, model weights, training examples, or screenshots. Review permission before including the material. Hugging Face's license guidance asks users to respect the licenses of code and data they reuse. Review the specific materials and conditions rather than treating a repository setting or a model's availability as a license grant.

A sensible portfolio demo uses inputs you are entitled to share. A redacted-looking sample can still reveal customer details in outputs, file names, logs, or examples. If permission is unresolved, keep the material out of the public demonstration rather than relying on obscurity or a label.

Secret handling also depends on the implementation. The management guide documents secrets as write-only configuration values, with runtime access through the app environment. That does not prevent your own code from printing or returning a value. Never put credentials in a public source file or require reviewers to supply a personal access token just to understand a portfolio example.

For Static Spaces, the overview says variables and secrets are available through client-side JavaScript. Do not treat a browser-delivered value as a server-side secret. A static case study with no credential-dependent interaction may be a better presentation than moving a private API key into the browser.

If the application includes a login button, that is another layer to assess. Hugging Face's OAuth guide describes adding a sign-in flow. A sign-in button alone is not evidence that every route, output, or API action checks the intended permissions. Do not infer private behavior from the appearance of authentication controls.

Completed visibility decision: private code, public synthetic demo

Noor is a fictional developer. Her original project classifies synthetic support tickets into three categories. She owns the demo code in this example and has an existing qualifying PRO subscription. Her requirements are to let an outside reviewer try the demo, keep the repository unavailable to that reviewer, and avoid using employer or customer material.

This is a planning example, not a deployed Space or a claim about a real model's accuracy. Noor completes this sharing inventory:

Portfolio item Completed sharing decision Reason in the fictional case
Synthetic ticket examples Include in the demo Authored for demonstration; no customer records
Working application Intended for outside interaction Reviewer needs to see input handling and output presentation
Source implementation Keep unavailable to outside visitors Noor's stated preference; code ownership is stipulated
Engineering explanation Prepare a separate readable case study Hidden source cannot serve as public implementation evidence
Prior employer's unrelated incident notes Exclude entirely No permission to use them is established

Her completed visibility choice is Protected, because it matches her stated code and runtime requirements. She rejects Private as the public application link for this purpose and rejects Public because it does not match her source-sharing preference. That decision is about the stipulated constraints, not a claim that Protected is the best default for every candidate.

Noor's prepared portfolio description reads:

Synthetic ticket-triage demo. I built the input validation, category-routing logic, and output explanation for this teaching project. The live interaction is intended to be public; the source repository is not shared. The case study explains the design and known limitations. This is not an evaluated production support system.

She changes “inspect the full source” to “read the design case study” because her chosen route does not provide public code access. If a role requires code review, she must provide another authorized code sample or discuss an agreed alternative. She cannot call a hidden repository publicly reproducible just because the app can be opened.

Noor also rejects the idea of adding confidential examples later without another review. A source-private configuration would not make the resulting public outputs appropriate to share. Her actual deployment and visitor checks remain unperformed in this article.

The hardware documentation says Spaces on free hardware can suspend after inactivity, giving two days as an example. Paid upgrades run indefinitely by default, but that is not a guarantee of error-free service. It can be frustrating to find a demo unavailable during review. State the fallback rather than promising that a free demo is always available or will start within a fixed time.

The disk-storage guide says the ordinary runtime disk is ephemeral: contents can be lost when the Space restarts or stops. It recommends attached Storage Buckets when persistence is needed. A file written during a demonstration is not automatically a durable portfolio artifact.

For a review, keep an independent explanation of the problem, your contribution, sample behavior, and limitations. Do not depend on a previous visitor's uploaded file or a temporary runtime output surviving. If the project does need persistent data, determine the storage and access requirements before enabling that path; this article does not attach a volume or provision a bucket.

A useful fallback should let a reviewer understand your contribution even when they cannot try the app. A decorative screenshot with no input, output, or explanation gives a reviewer little to assess when the application is unavailable. Prepare enough context to show what you built without claiming that a static description proves runtime reliability.

Completed visitor audit and fallback artifact

The following is an original fictional review of Noor's proposed portfolio. The observations are stipulated scenarios, not results from an actual browser test. Mara is a fictional outside reviewer with no collaborator access.

Stipulated visitor observation Completed interpretation Chosen response in the review
Mara can use the Protected app but cannot read its repository Consistent with the intended split Describe source availability honestly
A mistakenly supplied Private copy returns not found Outside access is not established Remove that copy as the public destination; do not ask Mara to bypass access
The intended demo is sleeping or temporarily unavailable Live interaction cannot be reviewed now Offer the prepared case study instead of promising immediate recovery
An example result existed only on temporary runtime disk Continued availability is not established Use the independently retained teaching example

This audit resolves which evidence can accompany the proposed link. It does not mark the link verified, grant Mara collaborator access, or establish an actual startup time. Before real sharing, the owner would need to check the intended visitor route and current content; none of those account actions occurred here.

Noor's completed fallback case study contains this original synthetic example:

Problem: Route a short support request into one of three demonstration categories: account access, billing, or technical issue.

Input: “I can open my account, but the latest invoice lists two identical charges.”

Stipulated teaching output: Billing; the explanation points to the invoice and duplicate-charge wording. The interface should retain the original input for the reader to compare.

My contribution: Input validation, routing logic, and output explanation in the fictional project.

Known limitation: A request mentioning several issues can be ambiguous. This single invented example does not measure accuracy, fairness, or performance, and no inference request was executed for this article.

The fallback tells Mara what the project is intended to do and what Noor claims to have built. It preserves the distinction between a sample explanation and measured behavior. Noor avoids adding a success percentage or latency figure merely to make the portfolio sound more substantial.

Her final draft sharing decision is therefore a Protected-demo destination plus this separate case study, with the Private copy excluded from the public route. Actual runtime, repository permissions, and link verification remain outstanding. This is a completed decision under a fictional premise, not a production acceptance receipt.

A covered demonstration model sits beside an accessible case-study book with input, output, and limitation sketches.

Share the right destination and state its limits

The embedding guide says embedding requires Public or Protected visibility and explains the app's distinct hf.space address. Copy the actual intended destination rather than assuming that a repository page, embed, and private copy are interchangeable. Moving or renaming a Space can change its subdomain, so an old portfolio link needs another check.

Keep a short description beside the link: what the demo does, whether code is available, what data is appropriate to enter, and where the case study can be read. That gives a reviewer a useful route even if they choose not to interact with the application.

Choose visibility from the material you can share, retain independent evidence, and describe unresolved checks plainly. Then browse recent LandOffer roles and select the portfolio example that demonstrates responsibilities you actually performed. A readable, correctly scoped project supports that discussion without promising an interview or an employment outcome.

Sources and Further Reading