Skip to content
MINH VO A working notebook
by an engineer in Vietnam
Foundation8 min read

Choose a learning project you can afford to change

Choose a programming project with fictional data and a repeatable reset, then add real-world constraints deliberately.

Watercolor notebooks, an open sketchbook and a wooden pencil on a cream surface

For a learning project, I prefer mistakes that are easy to inspect and undo. That usually means fictional data, a small audience and a limited connection to external services. You can still study difficult engineering behavior inside that boundary. You do not need real payments or customer records to learn why retries, permissions and recovery matter.

A project is reversible when you can restore a known state, explain what changed and continue after a failed attempt without leaving someone else to absorb the consequences. Reversibility is not the same as triviality. A local notes application can expose concurrency and persistence questions that deserve careful work.

Compare projects by the cost of a mistake

Imagine choosing between a notes prototype and a small payments product. Both can teach forms, API requests and database writes. Their failure costs differ.

For a notes prototype, you can create fictional documents and reset the database after each exercise. A lost update is still a bug, but it affects data created for the experiment. A payments product introduces financial state, provider rules and actions that may be difficult to reverse. A test environment reduces some of those risks, but it needs a clear boundary from live credentials and live transactions.

The public Collaborative Notes repository documents a React and TypeScript notes project with editor and peer-related dependencies. Its existence provides a concrete example of an application-sized practice surface. Choose one of those features and test it directly; a repository description does not establish its current runtime behavior.

Write down what you are allowed to break

Before building the exercise, make a short environment contract. State where the data comes from, which account or local process owns it and what reset means. For a fictional note service, the contract could allow deleting and recreating all exercise notes while excluding any real personal documents.

AreaLow-cost practice choiceQuestion before expanding
DataA small fixture of invented notesDo I have permission to use the new data?
IdentityFictional accounts in an isolated environmentCould a test identity access real resources?
External actionsLocal files or provider test modeCan a retry send, charge or publish something?
RecoveryA repeatable reset and known fixtureHow would I detect an incomplete rollback?

Isolation needs checking too. A local process can still use an overly broad credential or write outside the intended directory, so inspect those connections before running a destructive experiment.

A fictional notes exercise has bounded data and a repeatable reset, while payments, real identities and public actions add separate review gatesView full-size image ↗

The diagram shows expansion as a series of explicit boundary changes. Adding a real email sender, for example, changes the project’s consequences even if the application code only gains a few lines.

Keep the hard question inside the small project

Suppose the lesson is duplicate handling. You can ask the notes service to create a document, interrupt the response and repeat the request. Inspect whether the application creates another note and whether that behavior matches its contract. The challenge is real even though the data is fictional.

If the lesson is access control, create two exercise users and a note belonging to each. Try direct requests that the interface would not normally offer. If the lesson is recovery, stop the process during a save and inspect the stored result after restart. Each exercise should have an expected outcome before execution.

Keep observations separate from assumptions. “The interface displayed an error” and “the write did not happen” are different claims. Recording both the visible behavior and the stored state teaches the kind of evidence gathering you will need in a larger application.

Expand when the next lesson requires it

A local prototype cannot answer every deployment or product question. At some point, you may need a real network boundary, a second device or a managed storage service. Add that environment because it is necessary to investigate a specific behavior, then update the reset and access rules.

A read-only first expansion keeps the number of external effects small. A public read-only demo can reveal rendering and network issues without accepting user content. If the project later accepts uploads, that creates new questions about file limits, ownership, retention and abuse. Those deserve their own design work.

The ACM Code of Ethics includes responsibilities concerning harm, privacy and authorized access. For learning projects, I take that as a reason to consider who could be affected by an experiment before treating a successful API response as permission to continue.

Preserve the experiment after it works

Keep the fixture, reset instructions and the failure case that taught the lesson. Another person should be able to understand which state is disposable and reproduce the behavior without guessing where the safe boundary ends.

The limitation of this approach is that an isolated exercise can feel smoother than production work. It may lack scale, organizational constraints and messy data. Record those omissions honestly. A small, reversible project is a place to develop a precise explanation, then choose which real-world constraint to introduce next.

Define the state that a reset must restore

A code checkout is only one part of an application’s state. The notes project may also have database rows, uploaded files, queued jobs, browser storage and credentials that point to other systems. Reverting a source change does not automatically restore any of those things.

Write a small reset manifest for the practice environment. It is an inventory of what must return to a known baseline, with an explicit boundary around resources that must not be touched. For a local fixture, use two fictional accounts, three invented notes and an empty job queue. Store attachments only in a dedicated exercise directory, and record the application’s configured database before running a reset.

StateBaseline for the exerciseEvidence after reset
SourceNamed commit plus documented local changesThe intended revision is checked out
DatabaseTwo accounts and three fixture notesIDs, owners and expected content match
File storageOnly the fixture attachmentsNo result from an earlier attempt remains
QueueNo pending exercise jobsA previous attempt cannot resume unexpectedly
Browser stateSession belonging to the chosen test userThe visible identity matches the request identity

The counts are deliberately small so you can inspect the actual records. A reset that reports success but leaves a queued retry behind has not restored the experiment. The delayed job can change the state after the next run starts and make a failure appear nondeterministic.

A reset manifest covers source, database, file storage, queue and browser state, while external effects sit outside automatic rollbackView full-size image ↗

Separate a code experiment from an environment experiment

Git worktrees let one repository have multiple checked-out working trees. They can make it easier to keep a baseline implementation beside an experimental branch. The documentation also makes clear that linked worktrees share repository data, while keeping selected state such as HEAD and the index separate.

A worktree is therefore useful for source organization, but it is not an application sandbox. Two checkouts can still read the same environment variable and connect to the same database. They may also use the same browser origin or external account. Verify those connections independently before assuming a different directory means a different environment.

For this exercise, name the database and attachment directory in the run instructions. Keep credentials out of the fixture itself. If the environment cannot be distinguished from a live service by inspection, stop the failure experiment and correct that ambiguity first. The learning objective is to study a failed write, not discover which real data the process happened to reach.

Choose the failure point before introducing it

A useful duplicate-handling experiment interrupts the response after the application has accepted a write. That timing exposes the difference between an unsuccessful interaction and an unsuccessful state change. Stopping the process before it receives the request answers a different question.

Describe the sequence as a fixture: begin from the known notes, submit a create operation, let the chosen persistence point complete, prevent the caller from receiving the normal response, then retry according to the operation’s contract. Record the stored note identifier and the returned result. Whether one or two notes is acceptable depends on the chosen duplicate policy, so state that policy before the attempt.

A controllable test hook in a local build can make the interruption repeatable. It should identify the point it pauses and remain outside the normal user-facing path. Randomly killing processes until something breaks may reveal a bug, but it provides weaker evidence about which boundary caused it.

Account for effects that cannot be reset locally

Deleting a local queue record does not unsend an email that a provider already accepted. Restoring a database snapshot does not make a public post disappear from copies outside the application. A local reset can therefore leave a different external reality from the one the database describes.

Use a local sink or an explicitly isolated provider test environment when the lesson does not require real delivery. If later work does need an external effect, add a verification and cleanup procedure for that provider rather than assuming the database reset covers it. Some effects require a compensating action rather than an exact reversal.

The useful question is not whether the project is perfectly reversible in every possible sense. It is whether the chosen experiment has a known starting state, bounded consequences and an observable route back to the state needed for another run. When that answer changes, update the environment contract before expanding the experiment.

Sources & further reading

  1. Collaborative Notes repository
  2. ACM Code of Ethics
  3. Git: worktree documentation
← Back to the journal
All notes

Illustration

100%