Juniors vs Seniors : le vrai coût en développement front-end

À la création d'un nouveau projet, il est facile de se tourner vers un profil junior. Un développeur junior en freelance coûte moins cher, fait facilement des promesses irréalistes, avance rapidement en faisant du "quick & dirty" : tout est dans le paraître.

Il est important de nuancer : développeur junior n'est pas synonyme de médiocrité, loin de là. En réalité un junior bien encadré peut s'avérer très productif et rigoureux avec une courbe de progression vertigineuse. Il suffit de l'accompagner comme il se doit.

Les risques pour un projet front-end

Prenons l'exemple d'un ancien projet que nous avons pu réaliser pour un de nos clients. Il s'agissait de la refonte d'un site vitrine.

Pitch assez classique : le client a d'abord fait appel à un développeur parmi son réseau qui s'avérait être un développeur front-end junior en freelance.

Après quelques semaines de développement, le projet présente déjà plusieurs bugs, et les fonctionnalités mettent de plus en plus de temps à être développées. Le client dit stop et décide de faire appel à des développeurs plus expérimentés

Surutilisation des librairies

Après un audit rapide du code, nous nous attardons sur le package.json :

1{
2  "name": "old-client-project",
3  "version": "0.1.0",
4  "private": true,
5  "scripts": {
6    "dev": "next dev",
7    "build": "next build",
8    "start": "next start",
9    "lint": "next lint"
10  },
11  "dependencies": {
12    "@radix-ui/react-dialog": "^1.0.5",
13    "@radix-ui/react-icons": "^1.3.0",
14    "@radix-ui/react-label": "^2.0.2",
15    "@radix-ui/react-slot": "^1.0.2",
16    "@tippyjs/react": "^4.2.6",
17    "antd": "^5.13.1",
18    "clsx": "^2.1.0",
19    "lucide-react": "^0.311.0",
20    "moment": "^2.29.1",
21    "next": "14.0.4",
22    "react": "^18",
23    "react-dom": "^18",
24    "sass": "^1.69.7",
25    "tailwind-merge": "^2.2.0"
26  },
27  "devDependencies": {
28    "@types/node": "20.11.0",
29    "@types/react": "18.2.47",
30    "autoprefixer": "^10.4.16",
31    "eslint": "^8",
32    "eslint-config-next": "14.0.4",
33    "postcss": "^8.4.33",
34    "tailwindcss": "^3.4.1"
35  }
36}

Nous remarquons rapidement des erreurs classiques qui peuvent entraver tout le développement d'un projet dès sa création : un mauvais choix de technologies.

• Mauvais choix de langage : javascript et non typescript qui est indispensable pour typer.

• Utilisation de plusieurs libraires qui répondent au même besoin : radix-ui antd lucide-react tippyjs

• Code difficile à maintenir puisque il y a plusieurs sources : sass tailwindcss

• Librairie dépréciée : moment au lieu de date-fns par exemple.

Les conséquences sur un projet front-end

On observe rapidement un paradoxe qu'il est important de garder en tête : bien que le code soit de mauvaise qualité, au début, le développeur junior a tendance à délivrer davantage de fonctionnalités qu'avec un développeur expérimenté.

En cause, le développeur prend des raccourcis qui lui font gagner du temps à un moment donné. En revanche, la dette technique augmente et le temps pour faire une modification également.

On observe donc une courbe exponentielle : plus le projet avance, plus une modification est couteuse, parce qu'elle prend énormément de temps. La dette technique devient trop importante et le client se voit obligé de faire une refonte totale de son projet.

Dans le pire des cas, la productivité est entravée dès les débuts du projet.

Les solutions apportées par des développeurs front-end freelance seniors

Faire appel à des développeurs qui ont de l'expérience permet de faire économiser de l'argent au client. Pas besoin d'itérer sur son projet maintes et maintes fois. Pas besoin de créer des v1, v2, v3… Il suffit de développer un MVP solide qui sert de base au projet en faisant appel aux profils qui peuvent le faire.

Un développeur junior n'est pas synonyme de médiocrité

Bien entendu, il ne faut pas tourner le dos aux développeurs juniors. Chacun débute à un moment dans son domaine et doit passer par l'apprentissage.

Un développeur junior bien encadré peut avoir autant de valeur ajoutée qu'un développeur qui a plusieurs années d'expériences. Il suffit de bien savoir composer son équipe de développeurs front-end en freelance.

Plusieurs solutions s'offrent au client :

• Faire appel à des profils différents selon des besoins spécifiques. Un développeur senior pour mettre en place le projet puis un junior pour le maintenir.

• Constituer une équipe de développeurs front qui permet d'encadrer le junior. En constituant par exemple un trio entre des seniors et un junior.

Quantité ne veut pas dire qualité

Bien que cela puisse paraitre assez évident, nos expériences passées me pousse à rappeler un élément important : une armée de développeurs juniors, qu'ils soient en stage, en alternance, en CDI, en freelance, ne fera jamais le poids face à une équipe de développeurs front-end intelligemment composée.

La capacité d'apprentissage et d'évolution stagne avec une équipe composée exclusivement de juniors. En revanche, une équipe mixte ou expérimentée permet de niveler les compétences globales de l'équipe.

Conclusion

Bien que le recours à un développeur junior présente des risques, il ne faut pas sous-estimer leur potentiel. Avec un encadrement adapté, un junior peut rapidement devenir un atout précieux.

Cependant, investir dans des développeurs seniors peut offrir une solution plus stable à long terme, évitant les risques liés à la dette technique.

Il est crucial de trouver le bon équilibre entre juniors et seniors pour assurer le succès d'un projet.

Choisir son équipe de développeurs freelance avec soin est essentiel pour garantir la qualité et la pérennité des projets front-end.