First Job Experience as a Web Developer

Writing this post gives me an opportunity to reflect on the valuable lessons I learned from my first job as a web developer five years ago, back in 2020. This is a reflection on that experience, highlighting both the technical aspects and the team dynamics.

Small Team, Big Responsibilities

For a full year, I worked in a small team consisting of three developers: two web developers (including myself) and one desktop application developer. This small team setup brought both challenges and opportunities. Although we were a team, we didn’t collaborate on a single project. Each of us was fully responsible for our own projects, from choosing the technology to implementation and completion.

Projects I Worked On

During that job, I had the opportunity to work on several diverse projects:

  • Job Portal Website

    My first project was to create a job portal website. For this, I used PHP and CodeIgniter (CI) as the framework. This experience taught me how to build a structured web application from scratch. I even conducted independent research on UI/UX design since we didn’t have a designer on the team. Additionally, I had to learn how to implement SEO practices to increase web traffic. I also learned to set up analytics tools to gain visibility into website metrics and create HTML pages that could be indexed by search engines specifically for job postings.

  • Web Version of a POS Application

    My second project was to create a web version of a Point of Sale (POS) application, which already had a desktop version. This time, I decided to use Laravel for the backend and Vue.js for the frontend. This experience introduced me to modern frameworks that were more flexible and efficient compared to the previous technologies I had used. Not only did this speed up the development process, but it also allowed me to create a UI that better supported functionality and improved user experience.

  • Support & Bug Fixes for an LMS

    In addition to building new applications, I was also involved in maintaining a Learning Management System (LMS) for a training institution. Here, I interacted with a legacy system. My tasks mostly involved debugging and ensuring the system ran smoothly. As far as I remember, there were some feature additions, but they were minor.

Building Technical Challenges

Working in a small team meant I had to handle many technical aspects on my own. Here are some of the challenges I faced:

  • Shared Hosting and FTP

    All our applications were hosted on shared hosting, and to update the applications, I used FTP. This was an eye-opening experience about the limitations of shared hosting, while also making me appreciate modern tools like CI/CD pipelines, which are now standard. I understood that despite its limitations, this decision had the advantage of being more cost-effective.

  • No Version Control

    At that workplace, version control was not used. However, I realized its importance and started using Git for my own projects. Even though it was a simple implementation, it helped me track changes and learn to use tools like GitHub.

  • Application Security

    I once received an email reporting an XSS attack on one of the applications I built with CI. After investigating, I discovered that input sanitization in CI was not enabled by default. This was a major learning moment about the importance of web application security, something I hadn’t considered before. Unfortunately, due to budget constraints, the company couldn’t reward the reporter.

Valuable Lessons Learned

From this first job, I learned many things that became the foundation of my career:

  • Independence in Choosing and Learning Technologies

    With the freedom to choose technologies, I learned to evaluate tools based on project needs. This became an important skill in my subsequent jobs. The various limitations also shaped my way of thinking to be more flexible and pragmatic. Do what you can, with the tools available, as optimally as possible to deliver value to the business.

  • The Importance of Documentation and Version Control

    The absence of version control at work pushed me to learn and implement it on my own. This formed good habits that I still use to this day.

  • Security is a Priority

    The experience of handling the XSS attack report made me realize that security should always be considered from the very beginning of application development. Even something as simple as input sanitization—never trust user input.

  • Working in a Small Team Builds Multi-Skills

    Being in a small team forced me to learn many things, from backend and frontend development to deployment (and even UI/UX design). This made me more flexible and prepared to face various challenges. My manager even once asked me to research and prepare a presentation for a CRM project needed by a large restaurant chain. I was even invited to the meeting and got to see how business players try to solve organizational problems with the help of technology.

Closing Thoughts

My first job as a web developer might seem simple from the outside, lacking best practices and an ideal organization. But for me, it was full of valuable lessons that shaped me into the developer I am today. Working in a small team, facing technical challenges alone, and completing projects from start to finish was an irreplaceable experience.

This reflection serves as a reminder that every small step at the beginning of a career plays a big role in shaping our future. It’s not about where we work, but how we work and what we learn during our journey that truly matters.