Full-stack developer

A full-stack developer, also written as full stack developer or fullstack developer, works on both the user interfaces and the server-side processing of a web application. They connect what users see and do with the business rules and data needed for the product to work. Their work can cover designing a feature, developing it, testing it and maintaining it.

APIs allow application components to communicate. A full-stack developer needs to understand these relationships so they can change one part of the application while taking the others into account.

Technical responsibility depends on the product, the technologies used and the people in the team. The title does not mean that the developer has mastered every specialism on their own. They work with those responsible for the project, designers and relevant specialists, particularly when translating a user need into a technical solution.

Full-stack, frontend and backend developers: who does what?

• A frontend developer focuses on the interface and user-side interactions.
• A backend developer focuses on server-side processing, exchanges with other systems and data.
• A full-stack developer works across both areas and the connections between them, with the level of autonomy to be defined for each.

Understanding the differences between frontend and backend development helps clarify this division of responsibilities.

This hire affects the team's ability to develop an application as a whole. A change visible on screen may also require changes to server-side processing or the way data is stored. The challenge is to connect these changes so that the feature meets the stated need and remains maintainable after delivery.

Development quality also depends on testing, code reviews and maintenance. Finding the cause of an incident and checking the effects of its fix are part of the work, alongside creating features.

Coordination with other specialists remains necessary. Developing an interface does not automatically confer responsibility for design. Likewise, security skills should be assessed in relation to the assigned tasks and the support available.

• Clarify user needs with those responsible for the project and translate them into technical requirements.
• Design the solution's components and model the data needed for it to work.
• Develop interfaces, their interactions and their exchanges with APIs.
• Develop server-side processing, business rules and exchanges with data systems.
• Test components, their interactions and complete user journeys through the application.
• Contribute to code reviews and version control with other developers.
• Protect secrets, data flows and data in the development work assigned.
• Contribute to delivery automation according to the responsibilities defined within the team.
• Diagnose incidents, fix faults and maintain and enhance the application.

Several French education and training routes can lead into software development: the BTS services informatiques aux organisations, BUT informatique, a master's degree in computer science, an engineering school or the titre professionnel de développeur web et web mobile. These routes do not all provide the same preparation for full-stack development. A course title alone is not enough to establish a candidate's autonomy.

Useful knowledge includes understanding how an application works: connecting a user interaction, server-side processing and the data involved. Practical experience may cover interface design, API development, data modelling, testing or maintenance. These skills can also be developed through retraining or learning by doing.

The University of Helsinki's Full Stack open course illustrates an approach combining React interfaces, Node.js APIs, testing and databases. It serves as an educational example. These technologies are not a requirement for every role. Completing a training project does not, on its own, demonstrate the ability to work independently on a production application.

A structured assessment based on the role's criteria

GetPro prepares the assessment using a framework that prioritises the role's criteria and specifies how each will be assessed. This framework distinguishes what can be established from a candidate's career history from the skills that need to be explored in an interview. Open questions and concrete examples make it possible to examine key criteria beyond the job titles listed on a CV.

Reference checks complement this assessment by placing skills in the context of a past working relationship. These discussions aim to substantiate strengths and clarify areas of concern through concrete examples.

Ways to assess a full-stack developer

The questions and exercise below are suggestions for your recruitment process, to be adapted to the role's responsibilities. They illustrate how these principles can be applied to full-stack development, without describing a technical assessment protocol specific to GetPro.

1. Define the criteria before interviews

List the tasks to be assigned across the interface, server-side processing and data. For each, specify the expected outcome, the autonomy required and the people available to support the candidate after they join.

Use these criteria to compare candidates, without simply counting the technologies mentioned on their CVs.

If your company lacks technical expertise, involve an assessor who can examine the relevant components. Agree with them on the technical criteria to assess and keep the hiring decision connected to the role's requirements.

2. Explore a past piece of work

Ask the candidate to describe a feature from the user need through to the data. Ask them to distinguish their contribution from that of others and explain the choices they made personally.

Explore a difficulty they encountered, the solutions they considered and the fix they eventually chose. Also ask how they tested their work and what changed following the initial feedback.

A precise explanation of the components changed and their relationships is a positive sign. An answer that remains focused on tool names calls for further questions about the work actually completed.

3. Set a task close to the work expected

Choose an exercise limited to a feature relevant to your application. Explain the user need, relevant constraints and necessary technical information. Explain the assessment criteria before starting.

Fictional example: ask the candidate to plan how an existing form could collect an additional item of information. Ask them to describe the changes needed to the interface, API and data, and the tests they would plan.

Observe the coherence of their approach and the questions they ask when information is missing. Do not draw a general conclusion from a single hesitation over a tool. Compare your observations with the stated responsibilities.

4. Examine quality and maintenance

Discuss the unit, integration and end-to-end tests the candidate considers useful. Ask what each would check in the case presented.

Then explore how they would find the cause of an incident and verify its fix. Depending on the role, also discuss code reviews, data protection or delivery automation.

A sound approach links each check to a risk or an expected behaviour. If the candidate only addresses the visible behaviour of the interface, explore their understanding of data exchanges and server-side processing further.

5. Assess collaboration and team responsibilities

Ask for a technical explanation aimed at a non-specialist. Observe whether it makes the constraint encountered and the consequences of the proposed choice understandable.

Ask the candidate to explain how they would discuss a shared change with a designer or another developer. If the role includes people management, assess that responsibility separately from programming skills.

6. Compare the evidence gathered

Compare your observations with your initial assessment framework. Distinguish the skills demonstrated, those that remain uncertain and the support needs identified during the discussions.

With the candidate's consent, a reference check can explore a responsibility they held or a collaborative situation in more depth. Prepare precise questions based on the points to clarify, without asking for confidential project information.