Full-stack development: responsibilities and practical exercise
Full-stack development follows a feature from interface through processing to storage. It aligns contracts between these layers and prepares operation. Working across domains does not remove the need for specialist review, particularly for access, data and critical journeys.
These sheets describe activities and teaching exercises. They do not constitute job offers, certifying courses or recruitment promises.
Connect interface, server logic and data within a defined scope. Full-stack work supports end-to-end understanding without implying mastery of every speciality.
Typical activities
Follow an enquiry from interface to storage and confirmation.
Define component, API and data boundaries.
Test how changes affect the entire journey.
Responsibilities to agree with the team
Keep scope explicit. Advanced security, accessibility, infrastructure or analysis may require additional expertise and independent review.
A first piece of work to demonstrate
Deliver a complete feature with failure tests, startup instructions and documented limits.
This is an editorial description of common activities. Job titles and scope vary across teams; it is not a certification framework.
Deliver a registration course with validation, confirmation and searchable status.
Work on a copy or demo environment. Define the data used and the expected result before you begin. Keep your decisions and the difficulties encountered in order to be able to explain the process.
Define the responsibilities of each layer and the trade contract.
Build a complete first course before the secondary variants.
Test inconsistencies between interface and saved state.
Document delivery and recovery for another person.
Deliverable and checks
Present the demonstration registration with its visible states, service exchanges and stored record. Describe confirmation and recovery after interruption. Supply test fixtures, deployment instructions and checks another person can run.
Trace the same registration across all three layers, then interrupt an exchange in the test setup. Pending or failed processing must remain distinct from completion. Returning to the page should not silently duplicate the registration or lose its stored state.
Working on several layers does not dispense with distinguishing their responsibilities. A success displayed should not precede an operation that has failed.
Collaboration to explore: Back-end development.
Fictional deliverable excerpt : A data contract describes accepted values, an empty result and the error returned for an unknown value. The journey is tested from interface to processing, beyond a simulated response.
What passes between the roles : Share display states, data formats and a common test dataset. An interface using mock data does not validate the real exchange; a working server alone does not validate the interface either.
Fictional teaching material: this excerpt illustrates part of a deliverable. It is not a client reference, a complete specification or evidence of professional qualification.
Sample excerpt
Scenario: an enquiry cannot be validated.
Expected response: documented error status and affected fields.
Interface: retain values that remain useful.
Recovery: explain what to correct and allow another attempt.
Check: no enquiry created during this expected failure.
What the author should be able to explain
The contract covers both server effects and visible feedback.
A clear message does not replace server validation.
The check also verifies that data has no unintended effect.
Does a generic “error” message validate the journey?
It may not let someone resume the task. Handover should explain recoverable errors, information to retain and cases where the outcome is uncertain, without falsely announcing success.
Assess the quality of the work
For the exercise, a request is stored but the response to the browser is interrupted. Follow the operation from input to persistent state, then examine what visitors can conclude. Interface, API and storage should share compatible identifiers and states even when confirmation was not received.
Scroll the table horizontally to read every column. With a keyboard, focus the table area and use the arrow keys.
Assess the quality of the work
Skill
Evidence to examine
Failure to spot
Data contract
Align fields, units, identifiers and permitted states. Distinguish request receipt, processing and stored result according to actual service behavior.
The interface interprets acknowledgement as completed work or converts a value without preserving the unit expected by the server.
Result and repetition
Identify the created result and how its state can be recovered. Define repeated-request behavior when the first response never arrived.
Visitors retry without confirmation and create another record while the team cannot distinguish recovery from a new request.
Diagnosis
A failure can be located without exposing sensitive data.
The report confuses a sent request with a saved record.
Interface/server contract
Align field names, units, identifiers, permissions and error formats.
A server error reaches the correct field with useful wording; the journey retains non-sensitive inputs.
A focused next step
Interrupt the response after a fictional record is stored, then resume with the same context. Check the stored result, displayed state and diagnostic route available to the team. If automatic recovery is unsupported, explain the next step rather than hiding uncertainty behind a local success message.
A mirror clone backs up the Git repository and its history. Git LFS objects require an additional fetch, and a wiki has its own repository. For a handover, also inventory data and services that do not reside in Git.
If-Match compares a strong validator before a write. Under the illustrated contract, a stale version receives 412; keep the draft to compare changes.
Dates indicate when references were consulted. These facts are neither a site audit nor an overall compliance statement.
A review case to reproduce
The browser reports a refused success
Situation to examine
The interface confirms a record that the server rejected. The two parts of the journey show incompatible states.
Proposed check
Test validation refusal, network interruption and success in a demonstration environment. Connect each response to appropriate messaging and local state. Check recovery without duplicates or silent loss of useful values.
Evidence to retain
A table connects request, response, retained state and user feedback. Confirmation follows accepted results rather than the button click alone.
Fictional finding example
The server rejects the date field and creates no record. The browser nevertheless clears the form and says “Enquiry recorded”.
Interpret this outcome
Connect confirmation to the accepted server outcome. Retain useful values after rejection and explain the required correction near the date field.
Three complementary checks
Fictional cases: adapt these expectations to your test contract and retain the limits of the check.
1Shared contract
2Reconciled states
3Checked recovery
Scroll the table horizontally if needed; with a keyboard, focus it and use the arrow keys.
Scenario variations and expected evidence
Variation to test
Expected result in this case
Evidence to hand over
The server rejects fields
Retain useful values and explain correction
Server response and form after rejection
The response is lost after creation
Indicate uncertainty and look up the result
Tracked identifier and actual stored state
The corrected attempt succeeds
One creation and a matching confirmation
Created object and final interface state
Decision to hand over : Examine interface, response and data together before reporting this journey as successful.
In-depth exercise: Build a small library of files with research and proposal form. Follow an entry from its input to its display, using demonstration data. Set identifier, validation, storage, publishing status, and rendering. Test a rejected entry and a modified entry. An interface displaying "Received" should not suggest that the information is already published or verified. Also check the route during a network error.
What to deliver with your work
Data Schema and Publishing Cycle Status
Input and rendering of records interface
Server validation and error management
End-to-end scenarios on a test environment
Acceptance criteria
These criteria are a working basis to adapt to the context. For each, note the action taken, the expected result, the observed result and the information remaining to be confirmed.
The received, validated and published statements remain separate.
A server error is explained without unnecessarily losing the input.
The stable identifier connects the input, its modification and its display.
The full course is checked with an accepted case and a rejected case.
Explain where the data is validated, stored and transformed. Keep a reproducible scenario that runs through the interface and the server. Document the responsibilities of each layer as well as the limits of the demonstration environment. The handover must make it possible to follow a problem from a visible message to its technical cause without exposing private content or access parameters.
A complete exercise connects interface, data and processing. Choose a scope small enough to verify the entire workflow rather than multiplying unfinished features.
Limited end-to-end workflow
When to choose it
Useful for completing a request from entry through validation and storage to authorised viewing. Define the result of each step.
What to plan for
Include permissions, errors and repeated requests. Use demonstration data without private information from a real project.
Integration into an existing application
When to choose it
Suitable for a workflow built into established conventions. Identify the components, contracts and data affected by the change.
What to plan for
Check compatibility and document migrations. Prepare a return to a consistent state if the change must be removed.
A risk to anticipate
A screen and database do not prove that a workflow works. Handle permission changes, interruptions and incomplete data too.
How to decide
Present a short diagram and a reproducible demonstration. Follow a request from browser to result, then explain failure behaviour.
Compare the whole interface-to-data journey using identical edge cases. Partial integration differs from an end-to-end tested function.
Recurring operation
Allocate work across interface, services and storage. Record shared dependencies and incident responsibilities; ‘full-stack’ does not define these commitments.
Exit and handover
Request sources, contracts, test data and deployment procedures. Check recovery of every layer and compatible versions rather than handing over an unexplained archive.
Choose a synthetic reference traceable through the interface, processing and stored record. Follow a success and a rejection. A confirmation screen should match the verified server state; a missing notification remains an issue even if the record was saved.
How can a demonstration be made reproducible?
Describe setup, required versions, demonstration data and reset steps. Keep local configuration separate from secrets. Ask another person to run a journey from a clean environment, then record any steps that still needed spoken explanation.
How can a portfolio project avoid excessive scope?
Choose a verifiable main task and representative states. Complete validation, error handling and permissions before adding features. A limited, explainable workflow makes decisions easier to assess than partially implemented functionality.