A field notebook · 2021–2023
The pieces worked.
The whole didn’t.
A game, a library, a registration form. Small projects taught me something much larger than their feature lists: how to follow a problem across the seams.
It worked until the next step.
A form could accept a value that the service refused. A successful save could leave the screen showing yesterday’s state. Each piece looked reasonable on its own. Put them together and the person using the application met the disagreement.
Those early games, library exercises, registration flows and storefronts gave me a useful kind of repetition. The subject kept changing, but the same questions returned: where does the rule live, which state is authoritative, and how does the interface know that something actually happened?
I had started by asking whether a function was correct. I gradually learned to ask whether a complete journey was coherent. That is a much less comfortable question. It includes the invalid input, the interrupted request and the record that survives after the screen has gone away.
Follow one request all the way through.
Input is still a proposal. Show what is required and preserve it if the request fails.
Relational schemas made relationships explicit. REST services forced a boundary between a request and the rules behind it. Frontend state introduced another version of reality: what the application currently believes has happened. Authentication made that reality depend on who was asking.
Connecting these layers taught me more than studying them independently. A registration flow is a small example, but it already carries questions about validation, duplicate records, failure and recovery. A library application adds identity and relationships. A storefront adds changing state and the consequences of acting twice.
The diagram is deliberately small. Following a single request is often enough to discover where an assumption changed hands. The browser’s message, the service’s decision and the stored record should describe the same event, even though each layer has a different responsibility.
The most useful thing I learned was how to keep following the question.
Repeat the work. Change the question.
Rebuilding familiar patterns in different languages and frameworks helped me separate a tool’s conventions from the problem itself. A framework might make a route easy to write. It cannot decide which rule must remain true when two requests arrive together.
Breadth has a cost: it is possible to collect technologies without gaining much judgment. I tried to counter that by returning to complete, narrow experiences. Model the behavior, connect the layers, then inspect the places where the model breaks. Each pass made the next application easier to reason about.
Consider a save button. Disabling it after a click helps communicate that a request is in progress, but it does not prove the operation happened only once. The service still has to decide how to handle repetition, and the screen still needs a response it can interpret. That small interaction crosses several boundaries before it becomes dependable.
Once I began reading an application this way, errors became more informative. A mismatch was a clue about responsibility. Instead of patching the visible symptom immediately, I could ask which layer had made a promise that the next layer did not understand.
This is why I still value those exercises. They were not miniature versions of impressive products. They were places to make assumptions visible while the consequences were still small. Later work became more complicated, but it kept speaking the same language: state, responsibility, identity and time.
Related work & references
Selected public entry points and related portfolio pages. A company website or profile is context, not a claim that private source code is available.
Scope, context & further questions
Supported by the public progression of programming, data, web, service, and application repositories beginning in 2021.
- Continuous public practice: 2021→. The build history begins with foundational exercises and grows steadily into complete applications.
- Interface to persistence: Full path. Work spans UI, APIs, relational and document data, authentication, and deployment.
- Learning method: Repeat. Similar product patterns were rebuilt in different languages and frameworks to expose trade-offs.
Questions I am still working through
How can foundations be taught through complete experiences rather than disconnected syntax?
By teaching one small end-to-end journey at a time: model a rule, persist it, expose it through an interface, handle failure, then inspect what changed across layers. The lesson becomes the relationship between parts rather than a list of language features.
The open question is how much realism to include before the exercise becomes too large to reason about.
Which abstractions remain understandable when the original author is no longer present?
The ones that make ownership and invariants explicit. Clear inputs, outputs, state transitions, failure modes, and naming tend to survive framework changes better than clever indirection.
The real test is maintenance by someone who did not participate in the original design.