search
Enter at least two characters without personal information.

    LibraryArticles and FAQs Your projectRequest a quote
    LanguageEN ▾
    Methods and learning

    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.

    All job descriptions
    Illustration of design and review work on a computer
    AI-generated illustration

    Explore all 28 review cases — The browser reports a refused success

    Missions and responsibilities

    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.

    W3C: organising accessibility responsibilities across a team

    Practice exercise

    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.

    1. Define the responsibilities of each layer and the trade contract.
    2. Build a complete first course before the secondary variants.
    3. Test inconsistencies between interface and saved state.
    4. 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.

    Prepare website checks

    Risks and collaboration

    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.

    View the role comparison : Full-stack developer and Web integrator →

    Employment, trades and training
    An example to examine

    Define a contract between interface and server

    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

    1. The contract covers both server effects and visible feedback.
    2. A clear message does not replace server validation.
    3. 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
    SkillEvidence to examineFailure to spot
    Data contractAlign 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 repetitionIdentify 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.
    DiagnosisA failure can be located without exposing sensitive data.The report confuses a sent request with a saved record.
    Interface/server contractAlign 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.

    MDN: HTTP status codes. · Source consulted

    Documented reference points for this topic

    Open the same version with two editors, save the first and replay the second with the old validator. Also compare the stored data.

    Documented reference points for this topic
    ReferenceValue or syntaxScope
    RFC 8259 · JSON
    application/json · UTF-8Standard JSON permits neither comments nor trailing commas; strings use double quotes.
    HTTP · 308
    308 · LocationPermanent relocation: the request method and body are preserved.
    HTTP · 304
    If-None-Match → 304For a GET or HEAD request, an unchanged representation can be reused without resending its body.
    GitHub Docs · Repository backup
    git clone --mirrorA 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.
    HTTP · If-Match
    If-Match: "r7" → 412If-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.

    1. Shared contract
    2. Reconciled states
    3. Checked recovery

    Scroll the table horizontally if needed; with a keyboard, focus it and use the arrow keys.

    Scenario variations and expected evidence
    Variation to testExpected result in this caseEvidence to hand over
    The server rejects fieldsRetain useful values and explain correctionServer response and form after rejection
    The response is lost after creationIndicate uncertainty and look up the resultTracked identifier and actual stored state
    The corrected attempt succeedsOne creation and a matching confirmationCreated object and final interface state

    Decision to hand over : Examine interface, response and data together before reporting this journey as successful.

    Method reference : W3C WAI — User Notification · Source consulted

    Learning scenario

    Extended exercise and expected deliverables

    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.

    1. The received, validated and published statements remain separate.
    2. A server error is explained without unnecessarily losing the input.
    3. The stable identifier connects the input, its modification and its display.
    4. The full course is checked with an accepted case and a rejected case.

    Understand pre-launch checks

    Ongoing management and handover

    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.

    Organize site maintenance

    Compare two approaches

    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.

    Explore this decision further

    Compare scope and costs

    Setup
    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.

    Compare the costs of three web solutions

    Frequently asked questions

    What should an end-to-end exercise follow?

    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.

    Further reading

    Browse other resources