1. LandOffer
  2. Blog
  3. All articles
  4. Digital Forensics Portfolio: Build an Evidence Timeline with Reproducible Findings

Job search

Digital Forensics Portfolio: Build an Evidence Timeline with Reproducible Findings

An actual local synthetic artifact exercise demonstrates inventory, timestamp normalization, source locators and independent checks with explicit limits.

9 min readLandOffer team

A digital forensics portfolio should let a reviewer trace each finding to a preserved artifact, a repeatable extraction and a clearly bounded interpretation. Start with one question you can answer from permitted material. Keep each timeline row tied to a source location and the meaning of its timestamp.

This guide actually parses an original synthetic artifact bundle created for the article. It contains custom SQLite records, authored file-time rows and harmless text files—not a disk image, a real browser history or customer evidence. No device was acquired or external system accessed. Use LandOffer.ai to identify relevant roles while keeping the portfolio’s demonstrated skills and limitations explicit.

An analyst aligns five artifact slips along a timeline while keeping one uncertain-time record separate.

Define the question and the evidence boundary first

Our question is narrow: What order do the supplied records describe for a sample file, and can they establish that the viewer opened newly downloaded content? The answer must distinguish a database row, a file’s bytes and an explanation of what happened. Matching names and nearby times do not automatically establish a causal sequence.

The fixture contains six inventoried input files. Its SQLite schema is original teaching material, not an implementation of Chromium, Firefox or an operating-system journal. The CSV’s creation and rename labels are authored fields, not metadata extracted from the host computer. State these boundaries in the README and report before presenting the findings.

For a real public training image, record its publisher, exact download, usage terms, acquisition context and supplied labels before examining it. Keep your findings separate from the training author’s answer key. This article did not download or examine such an image, so it cannot demonstrate partition analysis, deleted-file recovery or forensic acquisition.

SWGDE’s Computer Forensic Examinations guidance, version 2.0, emphasizes scope, contemporaneous notes, artifact sources and verification hashes. It also discusses confirming time-zone settings. We use those documentation principles for a limited teaching exercise; this is not a claim of laboratory compliance, professional certification or courtroom admissibility.

Inventory the inputs before interpreting their contents

The completed input inventory records each relative path, byte length and SHA-256 hash. There are three text files, one SQLite database, one CSV and one provenance JSON file. The parser checks those hashes before reading and again afterward. All six input hashes matched the baseline before and after the actual local runs.

The two files downloads/summary.txt and archive/summary.txt each contain 97 bytes and are byte-identical. Their full SHA-256 value is:

b5bedd75b371f8847c08effd0ed33bbca56858ba42fe8da2f81cbb500fdae7f3

The draft text file contains 70 different bytes. The database contains the custom downloads and viewer_events tables. Its 12,288-byte file hash begins 77a5a33c68cd; this is an abbreviated display, with the complete value retained in the inventory. Never treat an abbreviated hash as the full integrity comparison.

SWGDE’s Digital Evidence Collection guidance, version 2.0, November 20, 2025, describes documenting collected files and establishing hash baselines. Here the baseline begins after we authored the fixture. A matching hash shows consistency with those bytes; it does not authenticate a real source, prove who created a file or reconstruct transfers that were never documented.

Keep inputs, scripts, derived results and notes in separate directories. Describe this as an authored fixture and processing record; do not invent a chain of custody. Record the actual creation and processing history instead, including the fact that no physical device, write blocker or acquired image was involved.

Preserve the raw timestamp and its meaning

The parser keeps the original time string beside its UTC representation. It uses explicit offsets where supplied and leaves a timestamp without an offset outside the ordered timeline. That is a deliberate uncertainty policy for this fixture, not a universal treatment of every forensic format.

Python’s datetime documentation distinguishes aware values with time-zone information from naive values without enough information to place them unambiguously. In this exercise, 09:00:03-05:00 becomes 14:00:03Z; 15:02:00+01:00 becomes 14:02:00Z. The original strings remain available for review.

Normalization does not establish clock accuracy. Two sources can express times in known offsets while their clocks disagree. A sorted display also does not prove that an application wrote a record at the instant an underlying action occurred. State what each field represents and what clock assumptions remain untested.

For records with equal normalized times, the script uses the source locator as a deterministic display tie-break. That makes repeat output stable; it would not establish which physical action occurred first. The supplied fixture has no equal-time pair, so this ordering policy is documented without claiming a tie was empirically resolved.

Worked asset one: the actual extracted timeline

The actual run used CPython 3.12.14 and SQLite 3.53.4 on macOS, using existing standard-library modules without installing software. The database was opened through a read-only SQLite URI. Python’s sqlite3 documentation describes the supported database interface; the project includes the exact SQL rather than requiring a commercial forensic viewer.

From the included demo directory, using an available Python 3.12 executable, the repeat commands are:

python3.12 parse_timeline.py > replay.json
python3.12 reviewer_check.py > review-replay.json

The actual local executable and file hashes are retained in the run receipt. These commands read the existing fixture; they do not regenerate its input database. Other environments were not independently tested.

One extraction query is deliberately visible:

SELECT id,target_path,started,completed
FROM downloads ORDER BY id;

The selected ID remains attached to both timestamps from the row. The parser does not merge those two fields into one generic “file event.” A separate query reads the viewer table, and CSV line numbers identify the exported file-time records. This preserves the distinction between a recorded download interval, an application observation and an authored filesystem-style entry when all three appear in the same display.

Six timestamp records produced five ordered entries and one unplaced record. All ordered times below are February 12, 2026, UTC:

UTC time Retained source locator Meaning in the authored schema
14:00:00 artifacts.sqlite, downloads ID 41, started Download-start record for downloads/summary.txt
14:00:03 artifacts.sqlite, viewer_events ID 7 Viewer-open record naming that path
14:00:04 artifacts.sqlite, downloads ID 41, completed Completion record for the download
14:00:05 file-times.csv, line 2, F1 Authored creation-time record for the download path
14:02:00 file-times.csv, line 3, F2 Authored rename record naming the archive path

F3 stays in the unplaced list with its source line, path, raw time and reason. Its 2026-02-12T14:03:00 string has no offset. The parser does not silently append UTC or discard the row. The missing context remains part of the deliverable.

The immediate finding is an ordering conflict: the viewer record precedes the recorded download completion by one second. That is a fact about the authored records after normalization. It is not proof that someone read an incomplete download, that the clocks were synchronized or that an actual network transfer happened.

Likewise, matching bytes at the archive and download paths do not prove that the recorded rename operation created the archive copy. The fixture was authored with both files. Describe the content relationship and the recorded event separately rather than converting their coexistence into a witnessed operation.

Distinguish a tool’s feature description from your execution

The official Autopsy timeline overview describes combining file, web-artifact and other extracted timestamps, with aggregate and detailed views. We read that public description; we did not run Autopsy, ingest this bundle into it or validate its current parsers.

If your own project uses Autopsy or another forensic tool, record the version, ingest modules, data-source type, settings and artifact location that produced each finding. A screenshot showing a cluster is not enough if a reviewer cannot locate the underlying event. Preserve exports and explain any filters that hide context.

This Python exercise demonstrates extraction and checking of the authored schema. Its strength is that the small schema and processing rules are inspectable. Its limitation is that it does not establish expertise with a real browser format, disk image or commercial tool. Choose portfolio language that accurately reflects what you executed.

A second analyst checks source records beside two competing explanations and a preserved original file.

Worked asset two: an independent verification and challenge record

The separate reviewer_check.py script does not import the parser or read its saved timeline. It directly queries the raw SQLite fields and reads the CSV, compares the text files, then launches two fresh parser processes. This is an independent code path written for the exercise, not a second human examiner’s review.

Its completed checks and their limits are:

Check actually executed Observed result What the result does not establish
Query viewer ID 7 and download ID 41 directly Viewer’s normalized time is one second earlier The actual order of actions on a real device
Inspect all three CSV rows One lacks an offset What time zone that row should have used
Compare download and archive bytes Both 97-byte files are identical Which path supplied the viewer’s content
Append control text to a temporary derivative SHA-256 changes; original input stays untouched Resistance to every corruption or tampering scenario
Run the parser in two fresh processes Output bytes and hashes match Cross-platform validation or correctness for arbitrary evidence
Recheck the input inventory All six input hashes match baseline Authenticity of the authored scenario

The independent review records two alternative explanations. The viewer might have referenced pre-existing or cached content at the named path. Alternatively, differences in clock accuracy could explain the ordering. The supplied artifacts do not distinguish these possibilities, and neither hypothesis was tested against a live application.

The completed challenge conclusion is: “The record-order conflict is reproduced. Byte-identical copies are confirmed, but the content read by the viewer and the relationship between recorded clocks remain unresolved. No person, unauthorized act or real transfer is attributed.”

For a future authorized examination, useful additional evidence could include application field semantics, clock configuration and appropriate content or event context. Those are proposed investigative needs, not data acquired here. The temporary changed file is only a hash-detection control and never replaces a source artifact.

Package a report that another reviewer can challenge

Place the inventory, original fixture, parser, independent check, outputs and short report together. Give each finding a source locator and state the interpretation separately. A reviewer can compare viewer_events ID 7 with downloads ID 41 and inspect the retained offsets when challenging the one-second conflict.

Keep the unplaced record visible beside the timeline. Record tested versions, exact commands and the boundaries of your checks. A passing replay proves agreement between those runs, while direct source checks support particular transformations. Neither turns the small script into a validated parser for every possible input.

A truthful portfolio summary is: “Built a reproducible synthetic artifact timeline using Python and SQLite; preserved source hashes and row locations, retained an unresolved timestamp and independently reproduced a record-order conflict with alternative explanations.” It does not claim disk-image acquisition, deleted-file recovery, real-user attribution or a completed criminal investigation.

When selecting roles on LandOffer.ai, use this packet to explain the analysis you actually performed. If a job requires image acquisition or specific forensic software, identify that as a separate skill to demonstrate with appropriately authorized material. Include the repeat commands, source locators and unresolved questions with the report.

Download the worked example files

Download the curated educational companion. Read PUBLICATION-README.md after extraction for the public file layout, replay commands and requirements. The listed offline Python checks were rerun from the extracted archive in a disposable directory. The earlier local report and commands describe the original evidence environment; use the companion README for the portable layout. No whole evidence directory, credentials or compiler binaries are included.

Sources and Further Reading

Official sources checked October 23, 2026. The actual executable work used only this article’s original synthetic local files; no private case, device or disk image was examined.