Job search
Share a Streamlit Portfolio with Recruiters: Public Apps, Private Access, and a Readable Fallback
Official Community Cloud access and availability guidance plus completed fictional audits and a locally checked synthetic aggregation example.
Share a Streamlit portfolio through a route the intended viewer can use, and provide a readable explanation that does not depend on the app running. Check public app access, private viewer authorization, and GitHub source access separately. Sending a URL does not resolve an access restriction.
For recruiters, the app should be an optional way to inspect your work rather than the only place your contribution is explained. Include the problem, synthetic or permitted data, a specific demonstration, and limitations in the fallback. Use recent roles on LandOffer.ai to choose which skills the project should demonstrate before adding another feature or sharing route.

Establish which Streamlit environment you are describing
This guide focuses on Streamlit Community Cloud. Other hosting arrangements, including Streamlit in Snowflake or a company's own infrastructure, can have different access controls. We checked current official Community Cloud documentation on October 20, 2026, with full native browser reads of sharing, management and secrets guidance.
We did not deploy an app, log in, inspect a private workspace, invite a recruiter, change repository permissions, or test a live Streamlit application. The access audits below use invented conditions. We checked one small aggregation fixture locally with Python's standard library. That check establishes only the stated synthetic results, not Streamlit behavior or production performance.
Identify three separate destinations: the running application, any source repository you intend to share, and the readable portfolio explanation. They may have different audiences. Your app can render while its repository remains inaccessible, or your explanation can open while the live app is asleep. Check each route according to the evidence you want it to provide.
Distinguish public app access from private viewer access
Streamlit's sharing documentation describes repository-based default privacy and app-level sharing controls. It allows an app deployed from a private repository to be made public; do not treat that as an instruction to make the repository public. Public app access and source-code access need separate review.
A private app requires explicit access and sign-in. The documented viewer routes include Google authentication or single-use emailed links. An uninvited recipient does not gain access merely by receiving the app URL. The documentation also warns that inviting viewers grants analytics access and the ability to invite further viewers; review that scope before treating Invite as a neutral link-sharing shortcut.
Choose the audience deliberately. If a project uses information you are not permitted to publish, making it public for convenience is not an appropriate access fix. A separately prepared synthetic demonstration or a permitted static explanation may be a better portfolio artifact. We made none of those permission changes for this article.
The question is not whether a recruiter is technically capable of signing in. It is whether that particular route is appropriate, authorized and understandable for the material you are sending. Do not add repository write access just to solve a viewer's app-access problem.
Worked access audit: three routes, three decisions
Consider fictional data engineer Leon, who built a personal build-duration explorer. It uses invented CI-job records, not employer logs. He is considering a public demo, a private app and a repository link. These are assumed scenarios for a completed decision exercise, not accounts we inspected.
| Fictional route and condition | What a recruiter could inspect under that assumption | Completed decision |
|---|---|---|
| Public app, approved synthetic data; source repository private | The app's visible output and interactions, but not necessarily the source | Offer the app only with a readable contribution explanation; label source availability accurately |
| Private app; intended viewer not yet authorized | An access or authentication boundary rather than the project | Do not describe the URL as ready for unrestricted review; use the permitted fallback while deciding whether a scoped invitation is appropriate |
| Repository link points to a private development workspace | No source review without the appropriate access | Do not imply the recruiter can inspect code; prepare an authorized public sample or omit the source link |
Leon selects the synthetic public-demo route as his intended portfolio format, with a separate explanation. That is a design decision in this exercise, not a claim that a public app was deployed. He does not turn the original private workspace into a public repository or grant someone developer access.
The audit also corrects the label a reviewer would read before opening the project. “Full source and live app” would be inaccurate for the first row. His corrected label is “Interactive synthetic-data demo; implementation and checks summarized below.” If he later provides a shareable source sample, he can identify exactly what it contains rather than implying it is the complete original workspace.
A private app is not inherently unsuitable, but the reviewer needs an appropriate route and clear expectations. Leon's unresolved invitation question stays separate from the ready-to-read explanation; it does not become a reason to broaden every permission at once.
Write a fallback that explains one complete demonstration
A fallback should let someone understand the project even if they choose not to run it. A thumbnail and “click here” cannot explain input assumptions, your contribution, or a result's limitations. Include a short project narrative, one inspectable input-to-output example, and the boundary between what you implemented and what you verified.
For Leon's fictional project, the fallback is a completed mini case study rather than a promise that an app exists. Its intended first paragraph is: “I built a personal explorer for synthetic CI-build durations. It filters by date and success status, shows how many duration values are missing, and computes a mean only from complete values. The example demonstrates aggregation and data-quality handling; it is not evidence of a real engineering team's performance.”
The invented input contains six rows:
| Date | Job | Status | Duration in minutes |
|---|---|---|---|
| October 1 | API | Success | 8 |
| October 1 | Web | Success | 12 |
| October 1 | Worker | Failed | 20 |
| October 2 | API | Success | 10 |
| October 2 | Web | Success | 14 |
| October 2 | Worker | Success | Missing |
Selecting October 2 and Success yields three selected rows, two complete durations, and one missing duration. The mean is (10 + 14) / 2 = 12 minutes. Treating the missing value as zero would produce a different and unjustified result; the fallback explains why the denominator is two rather than three.
We actually executed a local Python standard-library fixture using these six invented rows. Five assertions passed, covering the October 2 result, October 1's success-only result, and an empty date returning no mean. No Streamlit package, app session, upload, deployment, external data source, or browser interaction was involved in that check.
Leon's proposed demonstration path is therefore specific: select the date, select successful jobs, inspect the missing-value count, and compare the mean with the two included durations. It is a proposed UI path, not a claim that we exercised those controls. A recruiter can still inspect the supplied table and arithmetic without opening an app.
State the contribution and limits beside the result
The fallback's contribution paragraph says: “My contribution is the filter-and-aggregation logic, explicit missing-duration handling, and a presentation that keeps sample size visible. The local fixture checks the stated aggregation cases. It does not validate the deployed interface, accessibility, concurrent use, or all possible inputs.”
This is more defensible than “Built a production-ready analytics platform that improved deployment speed.” Leon has no real production adoption or measured operational improvement in this exercise. A synthetic mean cannot establish either outcome.
He also declines to call the two-day fixture a trend analysis. It contains too few invented observations and no causal evidence. The example is useful because a reviewer can trace the selected rows to the displayed number, not because its values resemble a business result.
If Leon adds a screenshot or recording later, its caption should identify the selected date, filters, data source and artifact version. Label a captured result with its date selection and artifact version so an older output is not mistaken for the current implementation. Keep the readable explanation accurate even when the live interface changes.

Plan for sleep and resource limits
Community Cloud's management guidance says apps without traffic for twelve hours go to sleep and authorized viewers can wake them. It also warns that resource limits can cause throttling or failure. The numerical resource table on the page is labeled February 2024, so we do not present those figures as a guaranteed current capacity allocation.
A fresh link check is useful, but it does not guarantee immediate availability when a recruiter opens the app later. Do not promise an instant launch, a particular wake-up duration, or continuous uptime based on one successful visit. A readable fallback lets the reviewer inspect the work while the live app remains unavailable or unused.
Avoid making the first demonstration depend on a large download, slow external API, a paid credential supplied by the viewer, or uploading a real resume. For a portfolio, a bounded synthetic example can show the important behavior with fewer prerequisites. That is a design recommendation, not a measured performance comparison.
If the app fails, distinguish the symptom from the cause. An error screen alone does not prove a resource issue, and a sleeping page is not evidence that the project was deleted. Use actual developer evidence when diagnosing, then keep the fallback's availability statement current.
Keep secrets and sensitive data outside the portfolio
Streamlit's secrets-management guidance says not to commit .streamlit/secrets.toml to a repository and describes storing secrets in app settings. That mechanism is not a guarantee that application code cannot reveal a secret in a rendered page, log, error, or downloadable output.
Review what the app actually exposes before any authorized sharing. A private repository does not make a public app's output private. Remove credentials and unapproved records from examples, screen captures, source samples and fallback text. Explain synthetic replacements accurately rather than presenting them as anonymized employer data when they were created from scratch.
The same review applies to outputs a viewer can generate. If a demonstration offers downloads, the exported material needs the same permitted-data boundary as the visible chart. A title saying “portfolio” does not change the sensitivity of an underlying dataset.
We did not install credentials, inspect real secrets, test isolation, or certify an app's security. The purpose is to choose an appropriate sharing artifact and state its limits, not to infer safety from the hosting label alone.
Send a useful project route, not an unexplained app link
An application or portfolio entry can introduce the project with its purpose, your contribution, the short demonstration path, and the readable fallback. State when source is unavailable or access requires an invitation. Give the reviewer enough context to decide whether to open the app, without claiming they will do so.
Before an actual authorized share, verify the exact viewer-facing URL and the fallback's own access conditions. A document inside a private drive folder is not an accessible fallback merely because it contains good prose. Review the intended audience without changing permissions more broadly than the material allows.
Match the project to the role you are pursuing, then continue comparing recent roles on LandOffer.ai. Include the traceable work example and contribution summary alongside the app route in your application materials.


