1. LandOffer
  2. Blog
  3. All articles
  4. Jupyter Notebook as a Work Sample: Package Static Results and a Reproducible Run

Job search

Jupyter Notebook as a Work Sample: Package Static Results and a Reproducible Run

Current Jupyter and GitHub documentation, two fresh local kernel runs and a completed delivery manifest separate readable results from reproducible computation.

9 min readLandOffer team

Package a Jupyter notebook work sample with a readable account of its results and a separate route for reproducing them. Give the first reader enough context to assess your contribution without installing Python. Give a technical reviewer the notebook, permitted inputs, environment details and a run instruction you have checked. Saved output alone does not establish that the current code runs from a fresh kernel.

This guide reviews official Jupyter and GitHub documentation checked October 20, 2026, and includes a small author-created example executed locally. We did not upload a notebook, publish a repository, access employer data or test a recruiter's environment. As you browse recent roles on LandOffer.ai, choose a sample that demonstrates work you can explain and are allowed to share.

A readable project report and a separate computational notebook packet sit together in a careful bookbinding workshop.

Give readers a useful result before asking them to run anything

Open with the question, the data's origin, your contribution and the result's limits. Someone screening a data-engineering application should be able to identify the transformation you designed. Someone reviewing an analysis should see why the comparison answers the question. A long sequence of imports and exploratory cells postpones both judgments.

Point readers to the data checks, method, result and limitations in a short introduction. Explain which parts you wrote, which came from collaborators or a tutorial, and how you changed them. Reusing a library does not mean you authored its algorithm; writing the integration and checking its behavior can still be a useful contribution.

Jupyter's notebook-format documentation distinguishes cell source, outputs and execution counts. The file can preserve code and previously generated results together. That structure lets someone read earlier results beside code. To establish a fresh run, execute the current source with its required inputs. Check that the saved result corresponds to the version you intend to share.

A recruiter may choose to read the explanation without running the notebook. A readable route reduces the work required to understand it, while the executable route makes deeper inspection possible. Whether an employer wants external work samples remains subject to its application instructions.

Choose a static route deliberately

GitHub's documentation says repository notebooks render as static HTML and custom JavaScript interactions do not work there. A working widget in your local session therefore does not establish the same experience in a repository preview. A private repository also requires appropriate access; a copied URL does not grant it.

nbconvert's usage guide documents HTML export, including a minimal basic template. Exporting gives you a separate artifact to inspect. Our basic-template export is wrapped in a UTF-8 page with narrow-screen scrolling; the unchanged result content remains a static reading artifact. It does not turn that file into a running notebook server. If a result needs a live kernel, provide a readable explanation or saved representation alongside it rather than relying on an inactive control.

For a first-pass reader, label chart axes and units, explain any omitted records, and put the relevant conclusion beside the output. A table of ten values can communicate a small result more clearly than a chart whose labels disappear at narrow width. Keep important context in text instead of placing it only inside an image.

Check the exact export you plan to share. External fonts, images, mathematical rendering or interactive dependencies can change what a viewer receives. We did not establish universal offline portability for every nbconvert template or output type. The example below uses simple text results to keep that dependency boundary small.

Reproduce the result from a known starting point

Prepare the run as a reviewer would encounter it: the documented working folder, the stated inputs and a new kernel. Jupyter's notebook overview explains that a kernel retains computational state. Running cells during exploration can leave variables available even after you remove the cell that created them.

Include the permitted input files or a truthful acquisition route. Replace machine-specific paths with documented relative paths where appropriate. If the analysis depends on a private database, a credential or a dataset you cannot redistribute, say so. A small authorized synthetic example can demonstrate a method without pretending to reproduce the unavailable production study.

Record the Python and relevant package versions actually tested. Distinguish the analysis dependencies from the tools used to execute or export the notebook. An environment file records a setup; it does not prove the setup succeeds on every operating system or with every package index still available later.

Stop at an execution error and resolve its meaning. Do not quietly continue through an error and describe the resulting file as a successful clean run. The nbconvert guide distinguishes execution from conversion and documents that execution normally stops on exceptions; its option to retain errors is not evidence that the analysis succeeded.

Executed example: repair a hidden dependency and a duplicate row

We created an original five-row build-duration fixture. It contains invented data, with no production logs or measured engineering improvement. The question is narrow: how does one repeated record affect the displayed totals, and can the corrected analysis run without prior session state?

Synthetic input row Stage Seconds Decision in this sample
B1 cache 60 Keep this build
B2 compile 90 Keep the first record
B2, identical repeated record compile 90 Remove the exact duplicate
B3 cache 30 Keep this different build
B4 compile 120 Keep this different build

Our first deliberately incomplete notebook had a cell that read rows without defining it. In a fresh kernel it failed with NameError. The repair puts the CSV loading and imports into the notebook itself. It also checks duplicate build identifiers: a repeated identifier is accepted as a removable duplicate only when the entire record matches. A conflicting record would fail that check instead of being silently discarded.

The corrected notebook ran in two separate fresh kernels under Python 3.9.6, using nbclient 0.10.2; we exported the first result with nbconvert 7.17.2. The analysis code itself uses Python's standard library. Both runs produced identical text output. The values are summarized here for readability; the retained execution files contain the original output formatting:

raw_rows=5 unique_builds=4 duplicate_rows=1
cache mean = 45.0 seconds
compile mean = 105.0 seconds
raw sum = 390 seconds
deduplicated sum = 300 seconds

The duplicate contributes the 90-second difference. The stage means describe two unique builds per stage in this fixture. They do not establish that caching made a real system faster or that removing duplicate rows is always appropriate. In real data, repeated identifiers need investigation against the event definition, not automatic deletion because two rows look similar.

This completed result has three separate pieces of evidence: a reproduced missing-variable failure, a corrected input-and-analysis path, and matching outputs from two clean executions. It is a useful small work sample because the decision and its checks are visible. We did not test other Python versions, a second computer, GitHub rendering or a hiring decision.

Build a delivery package around the verified version

Here is the completed delivery decision for that same local example. The table describes files we created and checked; it is not a claim that they were uploaded or sent to an employer.

Artifact Contents and verified role Delivery decision
analysis.html Static export of the first successful run, with explanation and results First reading route; inspect it without requiring a notebook session
analysis.ipynb Source notebook with Markdown and code, initially without saved execution output Technical rerun route, alongside the inputs
data/builds.csv The five invented records shown above Include because the sample is author-created and contains no private data
README.md Question, synthetic-data boundary, working-folder instruction and expected values Put the result and the way to verify it in one starting document
requirements-tested.txt Exact installed execution/export environment captured for this test Identify tested tooling; do not call it a cross-platform guarantee

The package separates a convenient read from a new computation. The source notebook does not need to carry stale outputs to make the result visible, because the checked static artifact provides them. A reviewer can choose whether to inspect the explanation, read the code or prepare a new execution.

With the recorded tooling installed, the documented command from the sample folder is:

python -m nbconvert --to notebook --execute analysis.ipynb --output analysis.executed.ipynb

The output filename keeps the source separate from a newly executed copy. For this article, we performed the two executions through nbclient and exported through nbconvert. The command above is the documented rerun route, not an additional command-line execution we claim to have measured.

Our package review keeps the intentionally broken notebook out of the reader's starting path. Its failure remains in the private local audit evidence. Identify the intended final version so the reviewer can follow the correction without choosing between several similarly named notebooks.

A repeated build record is set aside beside four distinct records and a checked result sheet.

Inspect everything the notebook can disclose

Review code, saved outputs, Markdown, embedded media and metadata before sharing. Clearing outputs does not remove a credential written in source, a private path in a comment or information preserved elsewhere. The notebook format supports attachments and rich output, so inspecting only the first visible chart is an incomplete review.

Consider a fictional alternative sample that reads an employer-only database and displays customer names. Removing the connection string while leaving its output would still disclose those names. Removing the output would still leave an execution dependency the recipient cannot satisfy. The completed decision should be to withhold that original and prepare a separately permitted example, not to claim the original became reproducible through deletion.

Label a replacement accurately. “Synthetic demonstration of my validation approach” tells the reader what is available. “Reproduces the company's production result” would require access and evidence that the replacement does not supply. Preserve collaborator attribution and dataset permissions alongside the explanation.

Jupyter's server security guidance treats notebook execution as code execution. Do not ask a recipient to disable protections, expose a personal server or trust unknown code merely to see your chart. We did not operate a public server or change trust, authentication or network settings for this example.

Finish with a readable result and an honest run boundary

Open the intended reading artifact and confirm that the question, contribution, key output and limitations survive the export. Then check that the executable package identifies its inputs and tested environment. Keep the static result and the source tied to the same version so a later edit does not leave them describing different analyses. For our sample, the expected-value check includes the five input rows, four retained IDs, both stage means and both totals. Checking only the 300-second total would miss a different transformation that happened to produce the same sum.

If a run fails on another machine, preserve the actual error and compare it with the recorded setup before changing the result claim. A missing package, absent input and failed analytical assertion are different problems. Reproducing a number also does not establish that the method answers the right question; explain that judgment separately.

Choose one relevant responsibility from a recent LandOffer role and connect it to the decision your notebook demonstrates. Give the reader a specific place to start and a result you can defend. Follow the employer’s file and link instructions; this package is a local teaching example, not a request to send an unsolicited attachment. A clean local run supports that bounded claim while leaving employer interest and other environments untested.

Sources and Further Reading