When someone visits a developer’s portfolio, they usually see the final result. They discover a polished interface, modern technologies, and professionally presented projects. Yet behind that showcase often lies a long series of attempts, mistakes, and forgotten projects.
What people do not see are the versions abandoned after days of work, the bugs that required hours of investigation, the applications that never left the local environment, or the countless experiments that served as learning opportunities.
Before what I now consider my first real deployment, I had already built more than fifteen projects.
Some were simple static websites created to learn the basics of HTML, CSS, and JavaScript. Others were dynamic applications involving databases, authentication systems, or multiple technologies working together. I had also developed and hosted several APIs to test different architectures and better understand how applications communicate with one another.
Most of these projects were never seen by the public, but each of them helped build the skills that would later become useful.
Today, I would like to look back on that period, explain how my first real deployment happened, and share a few lessons that may help those who are about to take the same step.
The Invisible Phase
Before every first deployment, there is a period that people rarely talk about.
A period filled with learning, trial and error, and repetition.
At that time, I had no clients, no production server, and no real professional experience. My world was mostly limited to my computer, my local development environment, and a strong desire to improve.
I spent a lot of time creating projects, modifying them, deleting them, or rebuilding them from scratch whenever I was not satisfied with the result. Some websites never grew beyond a few pages, while others became real laboratories where I tested new ideas.
Looking back, I realize that this invisible phase was probably one of the most important parts of my journey.
Not because it produced exceptional projects, but because it helped me develop instincts. By encountering the same problems in different forms, certain solutions gradually became second nature. I slowly learned how to approach bugs, structure projects, and anticipate common mistakes.
These instincts cannot be acquired simply by watching videos or reading tutorials. They are built over time through practice and repetition.
My First Hosting Experiences
After several months of development and experimentation, I became interested in hosting.
At the time, I could not afford a server or professional hosting. Like many beginner developers, I had to find free alternatives in order to learn.
That is when I discovered that there were many solutions designed for different needs and technologies.
Depending on the type of project, it was possible to use specialized platforms for static websites, modern JavaScript applications, PHP applications, APIs, or full-stack projects.
The hardest part was not necessarily finding a solution.
The hardest part was often knowing which one to choose and understanding its limitations.
I then started hosting different projects: static websites, dynamic applications, and even a few APIs.
However, despite those experiences, I do not consider all of those launches to be real first deployments.
Why?
Because some of them were completed with significant guidance, and I still did not fully understand what was happening behind the technical steps.
I could follow a process.
I had not mastered it yet.
And that difference matters.
The Importance of Experienced Developers
During my university years, I had the opportunity to meet a developer who was more experienced than I was.
He was both older than me, one of my instructors, and, to some extent, a mentor.
At a time when I was still discovering the world of deployment, he helped me publish a website on InfinityFree, a free hosting provider that is very popular among beginners.
That experience was incredibly valuable.
It allowed me to learn the basics of hosting, file management, certain server constraints, and the challenges that arise when an application works perfectly on a local machine but suddenly refuses to work once it is online.
However, looking back, I do not consider that experience my first real deployment.
Not because it was not real.
But because it relied heavily on the guidance of someone more experienced.
I followed the steps.
I understood some of what was happening.
But I was not yet capable of reproducing the entire process completely on my own.
Still, that experience taught me two important lessons.
The first is that you should never hesitate to ask questions. When someone has already encountered and solved a problem before you, a few minutes of conversation can sometimes save you several days of frustration.
The second lesson is just as important: when you receive help, try to understand the reasoning behind the proposed solution. Otherwise, the same problem may return later in a different form.
My First Real Deployment
Over time, I continued learning, experimenting, and hosting different projects.
Then came the moment when I completed a deployment that I could truly call my own.
This time, I understood much more about what I was doing.
I knew how to prepare my project.
I knew how to manage files, configurations, and the various steps required to make an application accessible on the internet.
Everything was not perfect.
I encountered errors.
I had to search for solutions.
Sometimes I had to repeat certain steps several times.
But this time, the process relied primarily on my own knowledge.
And when the project finally became accessible online, the feeling was different.
It was not simply about seeing a website running on the internet.
It was the satisfaction of understanding the path that had led me there.
The Website Was Online... Now What?
This was probably the part I least expected.
The deployment had succeeded. The pages loaded correctly. The features seemed to work as intended.
Yet I quickly realized that I had no real strategy.
The website existed, but I did not truly know what to do next.
I had presented my services. I had added a contact form. I had invested time in the design and user experience.
But I had not thought about content creation, visibility, attracting visitors, or turning that online presence into real opportunities.
I had devoted all my energy to building the website itself.
I had not spent enough time thinking about its actual purpose.
For a while, that portfolio remained online.
Then I made a decision that surprised several people around me.
I deleted it.
And no, it is not the portfolio you are viewing today.
Deleting Is Not Failing
That decision was not made impulsively.
At the time, deleting the website felt like admitting that I was not ready yet.
Looking back, I see things differently.
I simply realized that a website is not a finish line. On the contrary, launching it often marks the beginning of a new stage.
Afterward, it must be maintained, improved, secured, promoted, monitored, and continuously updated with value.
All of these responsibilities require skills that go far beyond simply writing code.
Sometimes moving forward also means accepting the end of a project that no longer aligns with your current goals.
Deleting that website was never a failure.
It was simply another step in my learning journey.
The Real Learning Started Afterward
The next phase of my journey was very different.
I began working on projects with classmates, collaborating with organizations, and developing solutions for small businesses.
But one of the most impactful experiences was undoubtedly my time at DigiWeb SARL.
That is where deployment became something tangible.
I learned by observing more experienced developers, asking questions, taking notes, and sometimes making mistakes that I later had to fix.
Gradually, concepts that once seemed complicated became more familiar.
Servers, environment variables, production environments, and automated deployment processes stopped being abstract ideas.
This understanding was not built in a single day.
It came through practice, real-world projects, and experience accumulated over time.
That is often how the most valuable skills are acquired.
A Few Tips for Your First Deployment
If you are currently preparing for your first deployment, here are a few pieces of advice I wish I had received earlier.
1. Start Simple
Your first deployment does not need to be perfect. The main goal is to understand the process and build confidence over time.
2. Treat Deployment as a Skill of Its Own
Building an application and deploying it to production are two different disciplines. Take the time to learn both if you want to become more independent.
3. Do Not Be Afraid of Free Solutions
A limited budget should never prevent learning. Use the resources available to you and focus first on gaining experience.
4. Ask Questions Whenever Necessary
Spending several days stuck on a problem that an experienced person can explain in a few minutes is not always the best strategy. Communities, mentors, and even modern tools can save you valuable time.
5. Document What You Learn
Take notes on the errors you encounter and the solutions you find. You may be surprised by how often certain problems return when you least expect them.
6. Try Multiple Platforms
Every hosting provider has its own strengths, limitations, and specific characteristics. The more platforms you explore, the deeper your understanding of deployment becomes.
Some Free Hosting Platforms to Get Started
Depending on the technologies you use, here are a few free platforms that can help you take your first steps:
- Vercel - https://vercel.com
- Netlify - https://www.netlify.com
- GitHub Pages - https://pages.github.com
- Cloudflare Pages - https://pages.cloudflare.com
- InfinityFree - https://www.infinityfree.com
- Render - https://render.com
- Railway - https://railway.app
- Koyeb - https://www.koyeb.com
Before choosing a platform, take the time to read its documentation and make sure it fits your project's requirements.
Conclusion
The portfolio you are viewing today is neither the first website I developed nor the first website I hosted.
It is the result of everything that came before it: the many projects I built, the static websites, the dynamic applications, the APIs, the mistakes I made, the failed deployments, the deleted projects, and the advice I received from people who were willing to share their experience.
If I had to start over from the beginning, I probably would not change much.
Because all those mistakes gave me something that no tutorial could truly provide: the confidence that comes from understanding not only that a solution works, but also why it works.
And in the long run, that understanding is worth far more than the satisfaction of succeeding on the first try.
Lorsqu'une personne consulte le portfolio d'un développeur, elle voit généralement le résultat final. Elle découvre une interface soignée, des technologies modernes et des projets présentés de manière professionnelle. Pourtant, derrière cette vitrine se cache souvent une longue série d'essais, d'erreurs et de projets oubliés.
Ce que l'on ne voit pas, ce sont les versions abandonnées après plusieurs jours de travail, les bugs qui ont demandé des heures de recherche, les applications qui n'ont jamais dépassé l'environnement local ou encore les nombreuses expérimentations qui ont servi de terrain d'apprentissage.
Avant ce que je considère aujourd'hui comme ma première véritable mise en ligne, j'avais déjà construit plus de quinze projets.
Certains étaient de simples sites statiques réalisés pour apprendre les bases du HTML, du CSS et du JavaScript. D'autres étaient des applications dynamiques intégrant des bases de données, des systèmes d'authentification ou plusieurs technologies à la fois. J'avais également développé et hébergé plusieurs APIs pour tester différentes architectures et comprendre le fonctionnement des échanges entre applications.
La plupart de ces projets n'ont jamais été vus par le grand public, mais chacun d'eux a contribué à construire les compétences qui me seraient utiles plus tard.
Aujourd'hui, j'aimerais revenir sur cette période, raconter comment s'est déroulée ma première véritable mise en ligne et partager quelques enseignements qui pourront peut-être aider ceux qui s'apprêtent à franchir cette étape.
La phase invisible
Avant chaque premier déploiement, il existe une période dont on parle rarement.
Une période faite d'apprentissage, de tâtonnements et de répétitions.
À cette époque, je n'avais ni client, ni serveur de production, ni véritable expérience du monde professionnel. Mon univers se limitait essentiellement à mon ordinateur, à mon environnement de développement local et à une forte envie de progresser.
Je passais beaucoup de temps à créer des projets, puis à les modifier, les supprimer ou les recommencer entièrement lorsque le résultat ne me satisfaisait pas. Certains sites ne dépassaient jamais quelques pages, tandis que d'autres devenaient de véritables laboratoires où je testais de nouvelles idées.
Avec le recul, je réalise que cette phase invisible a probablement été l'une des plus importantes de mon parcours.
Non pas parce qu'elle a produit des projets exceptionnels, mais parce qu'elle m'a permis de développer des réflexes. À force de rencontrer les mêmes problèmes sous différentes formes, certaines solutions devenaient naturelles. Je comprenais progressivement comment réfléchir face à un bug, comment structurer un projet ou comment anticiper certaines erreurs.
Ces réflexes ne s'acquièrent pas en regardant une vidéo ou en lisant un tutoriel. Ils se construisent avec le temps, grâce à la pratique et à la répétition.
Mes premières expériences d'hébergement
Après plusieurs mois de développement et d'expérimentations, j'ai commencé à m'intéresser à l'hébergement.
À cette époque, je n'avais pas les moyens de payer un serveur ou un hébergement professionnel. Comme beaucoup de développeurs débutants, je devais trouver des alternatives gratuites pour apprendre.
C'est là que j'ai découvert qu'il existait de nombreuses solutions adaptées à différents besoins et différentes technologies.
Selon le type de projet, il était possible d'utiliser des plateformes spécialisées pour les sites statiques, les applications JavaScript modernes, les applications PHP, les APIs ou encore les projets full-stack.
Le plus difficile n'était pas forcément de trouver une solution.
Le plus difficile était souvent de savoir laquelle choisir et de comprendre ses limites.
J'ai alors commencé à héberger différents projets : des sites statiques, des applications dynamiques et même quelques APIs.
Mais malgré ces expériences, je ne considère pas toutes ces mises en ligne comme de véritables premiers déploiements.
Pourquoi ?
Parce que certaines ont été réalisées avec beaucoup d'accompagnement et que je n'avais pas encore une compréhension suffisante de ce qui se passait réellement derrière les étapes techniques.
Je pouvais suivre un processus.
Je ne le maîtrisais pas encore.
Et cette différence est importante.
L'importance des développeurs expérimentés
Durant mon parcours universitaire, j'ai eu la chance de rencontrer un développeur plus expérimenté que moi.
Il était à la fois mon aîné, l'un de mes enseignants et, dans une certaine mesure, un mentor.
À une période où je découvrais encore le monde du déploiement, il m'a aidé à mettre un site en ligne sur InfinityFree, un hébergeur gratuit très populaire auprès des débutants.
Cette expérience a été extrêmement enrichissante.
Elle m'a permis de découvrir les bases de l'hébergement, la gestion des fichiers, certaines contraintes liées aux serveurs et les difficultés que l'on rencontre lorsqu'une application fonctionne parfaitement en local mais refuse soudainement de fonctionner une fois en ligne.
Cependant, avec le recul, je ne considère pas cette expérience comme ma première véritable mise en ligne.
Non pas parce qu'elle n'était pas réelle.
Mais parce qu'elle reposait en grande partie sur l'accompagnement d'une personne plus expérimentée.
Je suivais les étapes.
Je comprenais certaines choses.
Mais je n'étais pas encore capable de reproduire l'ensemble du processus de manière totalement autonome.
Cette expérience m'a néanmoins appris deux leçons importantes.
La première est qu'il ne faut jamais hésiter à poser des questions. Lorsqu'une personne a déjà rencontré et résolu un problème avant vous, quelques minutes de discussion peuvent parfois vous éviter plusieurs jours de blocage.
La seconde est tout aussi importante : lorsqu'on reçoit de l'aide, il faut chercher à comprendre la logique derrière la solution proposée. Sinon, le même problème risque de réapparaître plus tard sous une autre forme.
Mon premier véritable déploiement
Avec le temps, j'ai continué à apprendre, à expérimenter et à héberger différents projets.
Puis est arrivé le moment où j'ai réalisé une mise en ligne que je pouvais réellement considérer comme la mienne.
Cette fois-ci, je comprenais davantage ce que je faisais.
Je savais comment préparer mon projet.
Je savais comment gérer les fichiers, les configurations et les différentes étapes nécessaires pour rendre une application accessible sur Internet.
Tout n'était pas parfait.
J'ai rencontré des erreurs.
J'ai dû chercher des solutions.
J'ai parfois recommencé certaines étapes plusieurs fois.
Mais cette fois, le processus reposait principalement sur mes propres connaissances.
Et lorsque le projet est finalement devenu accessible en ligne, la satisfaction était différente.
Ce n'était pas simplement le fait de voir un site fonctionner sur Internet.
C'était la sensation d'avoir compris le chemin qui m'y avait conduit.
Le site était en ligne... et après ?
C'est probablement la partie à laquelle je m'attendais le moins.
Le déploiement avait réussi. Les pages s'affichaient correctement. Les fonctionnalités semblaient fonctionner comme prévu.
Pourtant, je me suis rapidement rendu compte que je n'avais aucune véritable stratégie.
Le site existait, mais je ne savais pas réellement quoi faire ensuite.
J'avais présenté mes services. J'avais ajouté un formulaire de contact. J'avais pris soin de travailler le design et l'expérience utilisateur.
Mais je n'avais réfléchi ni à la création de contenu, ni à la visibilité du site, ni à la manière d'attirer des visiteurs ou de transformer cette présence en ligne en opportunités concrètes.
J'avais consacré toute mon énergie à construire le site lui-même.
Je n'avais pas suffisamment réfléchi à son utilité réelle.
Pendant quelque temps, ce portfolio est resté en ligne.
Puis j'ai pris une décision qui a surpris plusieurs personnes autour de moi.
Je l'ai supprimé.
Et non, il ne s'agit pas du portfolio que vous consultez aujourd'hui.
Supprimer n'est pas échouer
Cette décision n'a pas été prise sur un coup de tête.
À ce moment-là, supprimer ce site me donnait l'impression de reconnaître que je n'étais pas encore prêt.
Avec le recul, je vois les choses différemment.
J'ai simplement compris qu'un site web ne représente pas une ligne d'arrivée. Au contraire, sa mise en ligne marque souvent le début d'une nouvelle étape.
Il faut ensuite le maintenir, l'améliorer, le sécuriser, communiquer autour de lui, analyser ses performances et continuer à lui apporter de la valeur.
Toutes ces responsabilités demandent des compétences qui dépassent largement le simple fait d'écrire du code.
Parfois, avancer signifie aussi accepter de mettre fin à un projet qui ne correspond plus à ses objectifs du moment.
Supprimer ce site n'a jamais été un échec.
C'était simplement une étape supplémentaire dans mon apprentissage.
Le véritable apprentissage a commencé ensuite
La suite de mon parcours a été très différente.
J'ai commencé à travailler sur des projets avec des camarades de classe, à collaborer avec certaines organisations et à développer des solutions pour de petites entreprises.
Mais l'une des expériences les plus marquantes a sans doute été mon passage chez DigiWeb SARL.
C'est là que le déploiement est devenu quelque chose de concret.
J'ai appris en observant des développeurs plus expérimentés, en posant des questions, en prenant des notes et parfois en commettant des erreurs que je devais ensuite corriger.
Progressivement, des notions qui me semblaient complexes sont devenues plus familières.
Les serveurs, les variables d'environnement, les environnements de production ou encore les processus de déploiement automatisés ont cessé d'être des concepts abstraits.
Cette compréhension ne s'est pas construite en une seule journée.
Elle est venue avec la pratique, les projets réels et l'expérience accumulée au fil du temps.
C'est souvent ainsi que s'acquièrent les compétences les plus précieuses.
Quelques conseils pour votre premier déploiement
Si vous préparez actuellement votre première mise en ligne, voici quelques conseils que j'aurais aimé recevoir plus tôt.
1. Commencez simplement
Votre premier déploiement n'a pas besoin d'être parfait. L'objectif principal est de comprendre le processus et de gagner en confiance au fur et à mesure.
2. Considérez le déploiement comme une compétence à part entière
Développer une application et la mettre en production sont deux domaines différents. Prenez le temps d'apprendre les deux si vous souhaitez devenir plus autonome.
3. N'ayez pas peur des solutions gratuites
Le manque de budget ne devrait jamais empêcher l'apprentissage. Utilisez les ressources disponibles et concentrez-vous d'abord sur l'acquisition d'expérience.
4. Posez des questions dès que nécessaire
Rester bloqué plusieurs jours sur un problème qu'une personne expérimentée peut expliquer en quelques minutes n'est pas toujours la meilleure stratégie. Les communautés, les mentors et même certains outils modernes peuvent vous faire gagner un temps précieux.
5. Documentez ce que vous apprenez
Prenez des notes sur les erreurs rencontrées et les solutions trouvées. Vous serez surpris de constater à quel point certains problèmes reviennent lorsqu'on s'y attend le moins.
6. Testez plusieurs plateformes
Chaque hébergeur possède ses avantages, ses limites et ses spécificités. Plus vous en essayez, plus vous développez votre compréhension du déploiement.
Quelques hébergeurs gratuits pour débuter
Selon les technologies que vous utilisez, voici quelques plateformes gratuites qui peuvent vous permettre de faire vos premiers pas :
- Vercel - https://vercel.com
- Netlify - https://www.netlify.com
- GitHub Pages - https://pages.github.com
- Cloudflare Pages - https://pages.cloudflare.com
- InfinityFree - https://www.infinityfree.com
- Render - https://render.com
- Railway - https://railway.app
- Koyeb - https://www.koyeb.com
Avant de choisir une plateforme, prenez le temps de consulter sa documentation et de vérifier qu'elle correspond bien aux besoins de votre projet.
Conclusion
Le portfolio que vous consultez aujourd'hui n'est ni le premier site que j'ai développé, ni le premier site que j'ai hébergé.
Il est le résultat de tout ce qui l'a précédé : les nombreux projets réalisés, les sites statiques, les applications dynamiques, les APIs, les erreurs commises, les déploiements ratés, les projets supprimés et les conseils reçus de personnes qui ont accepté de partager leur expérience.
Si je devais recommencer depuis le début, je ne changerais probablement pas grand-chose.
Car toutes ces erreurs m'ont apporté quelque chose qu'aucun tutoriel ne pouvait réellement offrir : la confiance qui naît lorsqu'on comprend non seulement qu'une solution fonctionne, mais aussi pourquoi elle fonctionne.
Et sur le long terme, cette compréhension vaut bien plus que la satisfaction d'avoir réussi du premier coup.
Cool 😎
Good morning Mr Angelo I hope you are doing well. I was thrilled reading your experiences and journey. Your story is remarkable and reflects dedication and perseverance You have come a long way, and your achievements are a testament to your hard work and commitment. Keep up the excellent work as usual. I wish you continued success in all your endeavors. May the future bring you even greater opportunities, accomplishments, and fulfillment. Ms Agboyinou Houssou Maria