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

From frontend to AI: keep the whole request in view

Move from frontend into AI with a small document assistant, clear system boundaries and evidence for each learning step.

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

My path has taken me from frontend development into full-stack work, including backend, DevOps, mobile, desktop and cloud, and then into AI. The most useful way I can explain that transition is through a request: what the user asks for, how the software handles it, and what evidence tells us the result is acceptable. The interfaces change. Responsibility for the result keeps growing.

For a developer considering a similar move, I would start with a small feature that crosses several boundaries. Learning a collection of tools can help, but a working feature makes the missing knowledge visible. An application that looks finished in the browser may still lose data, expose an unauthorized document or produce an unsupported answer.

Follow one request across the application

Consider a hypothetical document assistant. A user uploads a handbook and asks which expenses require approval.

The frontend must explain which file was uploaded, whether processing is finished and what the user can do after a failure. Those are familiar interface questions. The backend must decide who may upload a file, which document belongs to which account and whether a repeated request creates another copy. Cloud configuration determines where the file lives and which service identity may read it.

The AI component adds another question: does the answer actually follow from the available handbook? A successful HTTP response cannot establish that. The application might retrieve the wrong passage and return fluent, irrelevant advice. The MDN HTTP overview describes the request-response protocol; the NIST AI Risk Management Framework provides a broader way to consider AI risks. They address different parts of the same feature.

A handbook question crosses interface, API, cloud storage and AI evaluation boundaries, with different evidence required at each stageView full-size image ↗

The diagram keeps evaluation beside the answer path because it checks a different claim. A response can arrive quickly and still be wrong. An answer can be correct for a public handbook and still violate access rules when the underlying document belongs to another account.

Carry useful habits into the next domain

Frontend work gives you practice with state, asynchronous operations and the gap between what software does and what a person understands. Those habits transfer. A background ingestion job has pending and failed states just as a form submission does. A stale result needs a clear rule about which request it belongs to. A disabled button needs an explanation if the user is expected to act.

Some assumptions need replacing. Client-side validation improves feedback, but the server still has to validate incoming data. A user interface can hide a document, but authorization must protect the document when someone calls its endpoint directly. A screen remaining open does not mean a process, network connection or mobile application remains alive.

Write these differences down while building the example. A short note such as “the browser cannot decide ownership” is useful when connected to a test that tries another account’s document identifier. Without the example, it risks becoming a phrase you recognize without knowing how to apply.

Make the learning sequence depend on evidence

Start with a local page that submits a question and displays a fixed, clearly labeled answer. This lets you settle the interaction before introducing uncertain output. Next, connect it to a server endpoint and inspect both valid and invalid requests. Add document storage only after the identity and ownership rules are explicit.

Then introduce retrieval over a tiny collection of documents you are allowed to use. Keep a few questions whose answers you can verify by reading the source. Include one question the collection cannot answer. That case tests whether the feature handles missing evidence rather than producing an answer merely because the interface expects one.

Deployment comes with its own acceptance work. Record where configuration is supplied, how a failed release is detected and how you would return to a working version. A local demonstration establishes local behavior. It does not prove that deployed credentials, storage permissions or operational limits are correct.

At each stage, choose an observable stopping condition. “The unauthorized request is rejected by the server” is inspectable. “I understand backend security” is too broad to finish during a small exercise.

Keep the project small enough to explain

A broad learning project can become a collection of unfinished integrations. Keep the first version to one document type, one account model and a small question set. That leaves time to explain why a result is correct and what happens when a dependency fails.

There is a tradeoff. A narrow project will not teach every deployment pattern or AI technique. Its value is that you can understand the whole request and identify the next missing capability with some precision. You can later replace the storage layer, add a mobile interface or compare retrieval approaches while keeping the original behavior as a reference.

My public GitHub profile links frontend and application work that remains relevant to these questions. If you are planning your own transition, take one familiar feature and trace it beyond the screen. Preserve the evidence from each boundary, then choose the next topic where your explanation stops being specific.

Give the assistant a small evaluation fixture

A learning project becomes more useful when its expected behavior fits on a page you can read yourself. Create two short fictional handbook revisions. Revision one says that meals costing more than 500 units require approval. Revision two changes the threshold to more than 750 units. Use invented currency units so the fixture cannot be mistaken for a real employer’s policy.

Keep the revision identifier and its intended workspace beside the text. The application should know which revision is current and which account may read it. A collection containing both revisions is useful for testing, but only if the rule for choosing between them is explicit. Otherwise, the assistant may retrieve an old passage that is relevant to the words in the question while being wrong for the current policy.

Exercise caseExpected behaviorBoundary being examined
Authorized user, current revision, meal costs 800Explain that approval is required because 800 exceeds 750, with the current sourceRetrieval, reasoning and citation
Authorized user, current revision, meal costs exactly 750Explain that the stated rule says more than 750; do not silently change it to 750 or moreExact interpretation of the source
Authorized user asks about flight upgradesExplain that the selected text does not answer the questionMissing evidence
A user from another workspace requests the handbookApply the application’s access rule without returning restricted document contentAuthorization before content use
A result from revision one remains open after revision two becomes currentMake the source revision visible and follow the product’s freshness ruleInterface context and document lifecycle

These are expected outcomes for a hypothetical fixture. They are not measured model results. If you run the exercise, save the input, selected source revision, actual output and judgment for every case. That record makes a changed model or retrieval strategy comparable against the same requirement.

Five handbook-assistant cases separate supported answers, threshold boundaries, missing evidence, denied access and stale revisionsView full-size image ↗

The cases cross disciplines deliberately. A model-quality check cannot replace the workspace access test, and an authorization test cannot establish that the answer follows the current revision. The same screen contains the results of several independent contracts.

Compare a complete answer with a plausible one

For the 800-unit meal, an acceptable answer can be short: the current revision requires approval above 750 units, so 800 requires approval. A citation should lead to that rule. A response claiming that every travel expense needs approval adds a policy that the fixture never supplied, even if the sentence sounds sensible.

The OpenAI evaluation guidance recommends evaluation tied to the task and warns against relying on a general impression that a system works. In this exercise, judge source selection, rule interpretation and the absence of unsupported additions separately. A single overall score can hide which part needs work.

The exact-threshold case is useful because it resists vague grading. “More than 750” and “750 or more” produce different results at 750. That is a small example of a product requirement that needs both careful reading and a testable boundary. More fluent wording does not resolve the difference.

Before introducing model output, implement a reference response for the tiny fixture using explicit rules or a manually written answer set. This gives you a baseline for the user interaction and expected outcomes. A baseline does not need to be a production solution to be useful; it needs to make the requirement clear enough that added complexity can be judged.

Decide which problem belongs to the next iteration

Suppose the system answers the arithmetic cases correctly but selects the old revision. The next investigation belongs to ingestion, metadata filtering or retrieval. Rewriting the loading animation will not resolve that source-selection problem. If the selected source is correct but the screen attaches the answer to an earlier question, the next investigation belongs to request state and interface rendering.

If most failures occur on questions the handbook does not cover, consider whether the product should ask the user to choose another source or explain its limited scope more clearly. Adding a larger model may not supply the missing authoritative policy. You may need better source coverage, a narrower promise or a human escalation path.

This is where full-stack breadth earns its place. It helps you locate the failure and choose the next experiment. Depth is still required to repair that layer correctly. Keep the fixture small enough to understand, then add a new case when a real requirement exposes a gap. A growing set of explained cases is more useful than a larger demo whose success depends on asking the familiar question.

Sources & further reading

  1. MinhOmega public profile
  2. MDN: overview of HTTP
  3. NIST AI Risk Management Framework
  4. OpenAI evaluation best practices
← Back to the journal
All notes

Illustration

100%