1. LandOffer
  2. Blog
  3. All articles
  4. Technical Writer Portfolio for Job Applications: Select Samples for API Docs, Guides, and Editing

Job search

Technical Writer Portfolio for Job Applications: Select Samples for API Docs, Guides, and Editing

Build a technical writer portfolio with role-relevant API docs, task guides and editing samples. Check contribution, permissions and evidence.

10 min readLandOffer team

Build a technical writer portfolio around the work the job asks you to do: an API reference for developer documentation, a task guide for user instructions, and an annotated before-and-after passage for editing. Each sample should identify its audience, your contribution, the decisions you made and what you verified. If you cannot share employer-owned work, create an original sample with an explicit exercise label.

LandOffer publishes this guide and offers job-search tools. The examples below are newly authored fiction, supported by an actual local mock API exercise; they are not employer documents or evidence of hiring outcomes. We checked primary guidance on October 14, 2026. Use recent roles on LandOffer to identify the writing responsibilities you need to demonstrate before assembling a larger packet.

A classic editorial writing studio connects a small API reference, a first-task guide and a marked-up draft to the audience each document serves.

Choose samples from the responsibilities in the posting

Read the posting for the document types, audience and technical environment. “Developer documentation” can mean tutorials, reference maintenance, conceptual explanations or release notes. “Technical writer” can also describe internal procedures or customer help. Pick work that answers the particular request, then use a short introduction to explain its relevance.

Write the Docs' portfolio guidance recommends choosing strong sections, describing the creation process and tailoring the selection to the role. It specifically connects editing roles with before-and-after samples and API documentation with HTTP requests, responses and standards such as OpenAPI. That supports a targeted packet; it does not establish a universal required number of samples.

Role responsibility Useful first sample Question the sample should answer
API reference One documented operation and its responses Can a developer make and interpret this request?
User or developer guide A complete task with prerequisites Can the intended reader reach the stated result?
Editing Original draft, revised passage and rationale What changed, and why was it necessary?
Information architecture A small navigation proposal with context How does the structure support the reader's task?

Limit each sample to a task or section a reviewer can inspect. A short, complete task is easier to inspect than an enormous manual with no suggested starting point. If you link a long document, identify the section you authored and why it matters. Follow an employer's requested formats and counts even when your usual portfolio includes more material.

A tool list can provide context but cannot substitute for the work. Naming Markdown, a CMS or a diagramming app does not show whether you can explain a prerequisite or remove an incorrect statement. Show the document and explain the decisions that shaped it. For shared projects, state which parts you wrote, edited, organized or verified and credit collaborators without implying sole authorship.

An original API sample with a bounded verification record

Solenne is a fictional writer applying for a developer-documentation role. We created her sample packet for this article: a read-only task lookup reference, a first-task guide and an editing exercise. The accompanying Python fixture runs locally, returns invented data and makes no external calls. Its public demonstration string, DEMO_ONLY, is not a real credential.

The reference documents GET on a task path, a required demonstration header, no request body, a successful JSON response and two failure responses. There is only one existing record, task-17. Its title is “Check fixture rows” and its status is queued. The fixture does not implement task creation, deletion, persistence, real authentication or other status transitions.

Here is the operation summary from the authored reference:

Get one task. Send GET /v1/tasks/task-17 with Authorization: Bearer DEMO_ONLY. A successful response returns the existing fixture record as JSON. The request does not start or change the task. An unknown ID with the correct demonstration header returns a task-not-found response.

That summary ties the request to its purpose. The full sample also names the local startup command, the response fields and their types, the content type, the error bodies and the limits of the mock. The prose, fixture code and recorded checks let a reviewer inspect what was actually verified.

We executed three local GET requests on October 14, 2026 and recorded the results. The temporary server was stopped after the checks. The record below reports actual local behavior, not a production service guarantee:

Request condition Observed status Observed body Documentation consequence
task-17 with demonstration header 200 id, title and queued status Describe a successful read
task-17 without the header 401 demo_token_required error Explain the missing-header correction
Unknown path with the header 404 task_not_found error Explain the path/ID correction

MDN's HTTP status reference explains successful GET responses and the meanings of 401 and 404. The fixture's exact error strings and response precedence are our own implementation. For example, an unknown path without the demonstration header returns 401 first. Do not generalize that ordering to every API or replace the documented behavior of a real service with an assumption.

Make the reference precise enough to check

An API reference needs more than a successful request pasted into a code block. Identify the method, path, parameters, authentication requirements, input and output. Explain which values are examples and which are constraints. Name important errors and the reader's next action when that action is known.

For Solenne's sample, task_id is a string inserted into the path, and task-17 is the one existing fixture ID. The JSON response contains string fields for id, title and status. The documented status value is queued because that is all the mock implements. Calling it a complete task lifecycle would invent functionality. State this limitation in the reference where readers need it.

The OpenAPI Specification describes paths and operations, parameters and responses in a machine-readable API description. Its path-template rules connect a placeholder to a corresponding path parameter. If you provide an OpenAPI file, verify that its declared version, path parameters and responses agree with the implementation you are documenting. A heading called “OpenAPI” does not establish that a file conforms to the specification.

Our packet contains no OpenAPI document, so we make no schema-validation claim. A candidate targeting a role that requests OpenAPI could extend the exercise with a small specification and a recorded validation result. They should label the addition and its checked version. The existing prose-and-fixture packet demonstrates a narrower reference-writing task.

When documenting a real product, list unresolved questions for engineering or product review. Does an omitted field receive a default? Which error appears first? Are examples safe to publish? Keep unknown behavior out of instructions until it is established. An explicit question record shows judgment more clearly than confident text built on guesses.

A task guide that adds a different kind of evidence

A reference helps a reader look up an operation. A guide helps a reader complete a task. Write the Docs' software documentation guide emphasizes audience, installation instructions and concrete examples. Use those ideas to give the task a starting condition and a result the reader can recognize.

Solenne's original guide is “Read your first mock task.” Its audience can run Python 3 and curl locally but has not used this fictional lookup. The first step starts the supplied fixture in one terminal. The second sends the GET request from another terminal. The remaining steps interpret the response, address the documented errors and stop the local process.

The guide's completed task excerpt is:

Start the fixture on local port 8778 and keep that terminal open. Send the supplied GET request with the demonstration header from another terminal. Check HTTP 200 and application/json, then read id task-17 and status queued. No task is changed. Stop the fixture with Ctrl-C when finished.

The full guide also distinguishes a connection failure from an API error. If the connection is refused, the reader checks whether the fixture is running on the expected port. If another process uses that port, they choose an available one and keep the startup and request addresses consistent. Those instructions follow the local setup; they are not advice for bypassing a commercial service's controls.

A guide should not promise a result the sample cannot produce. Here the end condition is reading one invented record. It is not scheduling work, authorizing a user or measuring reliability. If the exercise grows, revise the prerequisites, examples and completion check together. A screenshot that still shows an old field name can undermine otherwise correct prose.

A completed before-and-after editing sample

The editing sample starts with a deliberately flawed passage we authored ourselves. It is not a confidential draft, a client document or an excerpt attributed to another writer:

Before: “Use the task endpoint with your key. If it fails, try again. This starts the task.”

The revision is specific about the operation and removes the invented mutation:

After: “To read the fixture task, send GET /v1/tasks/task-17 with Authorization: Bearer DEMO_ONLY. A successful response returns 200 and the queued record; the request does not start or change the task. For 401, check the demo header. For 404 with the header present, check the task path.”

An editorial proofreader compares an ambiguous task instruction with a precise read-only request, linking corrections to recorded response evidence.
Edit Reason Supporting evidence
Specify method, path and demo header Replace ambiguous endpoint/key wording Authored reference and local fixture
Remove “starts the task” The operation only returns a fixed record Fixture implementation and observed response
Separate error actions Repeating the same request does not repair the documented cause Recorded 401 and 404 examples

The annotation demonstrates technical correction and reader-focused editing. It does not show measured reductions in support requests or prove that users understood the revision. To make that kind of claim, a candidate would need actual evidence and permission to share it. Keep the claim proportional to what the sample establishes.

Preserve the before passage alongside the after passage when the employer allows that format. Explain substantial changes without turning the annotation into a second manual. A reviewer should be able to see the error, the correction and the reason. If the sample comes from team work, distinguish your editorial decisions from changes requested by an engineer, designer or subject-matter expert.

Package contribution, rights and verification together

Give each sample a short cover note. Solenne's original API note reads: “Self-directed educational exercise for developers using a local mock. I authored the reference, guide and editing passage and implemented the small fixture. Three local GET checks verified the documented success, missing-header and unknown-path responses. No production integration or user comprehension study was performed.”

That note is useful because it identifies the authoring work and the evidence without inventing a client. It also leaves room for discussion: a reviewer can ask why the errors are ordered that way, what the guide assumes and what a real deployment would require. The candidate can answer by pointing to the source, document and check record.

For employer-owned material, obtain the appropriate permission and follow restrictions before adding it to a packet. Write the Docs explicitly addresses written authorization from an owner with authority and recommends creating unrelated original content when work samples cannot be shared. Redacting a name does not automatically authorize publication. Keep customer data, credentials and unreleased details out of examples.

Our Markdown samples were exported to local HTML and inspected in a browser. The packet retains the source, fixture and check record. Those checks confirm the authored local exports, not public hosting or access through an employer's network. Verify the final external link separately: open it signed out, follow the exact sample route and check every linked file.

Finally, choose the order for the application. Solenne places the API reference first for a developer-documentation role, the guide second and the editing annotation third. For an editing role, she would lead with the annotated passage and use the reference as technical context. She would follow a specific sample request even if it changed that order. Check LandOffer's recent job listings and compare the packet with the responsibilities of the actual role before submitting it.

Sources and Further Reading