Introduction
As a fresh graduate in Information Systems, I have learned that developing a web application is not only about writing code and creating features. Understanding how a project is deployed, tested, and made accessible to users is also an important part of the development process. For the Tencent EdgeOne Makers challenge, I decided to use one of my own projects, 1st Course, as a practical case to explore the deployment process and understand how Tencent EdgeOne Makers can be used in a real development workflow.
1st Course is a web-based information management system that I developed for a non-formal tutoring institution. The system focuses on managing student information and financial records in a more organized and integrated way. Through this project, I wanted to go beyond the development stage and gain practical experience with source control, deployment configuration, troubleshooting, and web hosting.
About the 1st Course Project
The 1st Course system was developed to help a tutoring institution manage student information and financial activities. The main features include student management, monthly tuition payment (SPP) management, income records, expense records, and financial information. The system also provides different access levels for Admin, Owner, and Student users.
The application was developed using Laravel 11, PHP, MySQL, HTML, CSS, JavaScript, and Tailwind CSS. The project originally started as an academic project, but I wanted to take it further by experimenting with a real deployment workflow and exploring how deployment platforms can be used to make a project accessible outside the local development environment.
Figure 1. The 1st Course student and financial management system dashboard.
The dashboard represents the actual application that I developed. It provides an overview of the system and its main management features, giving users a central place to access the information they need.
Exploring Tencent EdgeOne Makers
After completing the main development of the project, I connected the source code repository to Tencent EdgeOne Makers through GitHub. I used the main branch as the production branch and selected Other as the framework because the EdgeOne demonstration was prepared as a static web page.
Figure 2. Build and deployment configuration for the 1st Course project on Tencent EdgeOne Makers.
The configuration process was straightforward and gave me an opportunity to understand how a Git-based deployment workflow works. Instead of manually uploading files whenever a change was made, the project source code could be managed through GitHub and then deployed using the configured production branch. For a developer who is still learning about deployment, this workflow provides a useful introduction to how source control and deployment can work together.
Understanding the Deployment Architecture
One of the most important lessons from this experiment was understanding the difference between a dynamic web application and a static web deployment. The complete 1st Course application is built with Laravel and depends on PHP and MySQL. Features such as authentication, student management, SPP payments, income, and expenses require server-side processing and database access.
Because of these requirements, the complete Laravel application needs a server environment that supports PHP and MySQL. For this reason, I did not attempt to run the entire Laravel application directly as a static website on EdgeOne. Instead, I prepared a static demonstration page that presents the 1st Course project and its main features.
This distinction was important because it helped me understand that deployment platforms should be selected based on the technical requirements of an application. A static website and a dynamic Laravel application may look similar from a user's perspective, but their infrastructure requirements are very different.
Deployment Experience
My deployment workflow can be summarized simply as Local Development → GitHub → Tencent EdgeOne Makers → Static Demonstration. I started by preparing the required static files in the project, committed the changes to GitHub, connected the repository to EdgeOne Makers, and configured the build and deployment settings.
After the configuration was completed, EdgeOne processed the project and deployed the generated output.
Figure 3. Successful deployment of the 1st Course project through Tencent EdgeOne Makers.
The successful deployment allowed me to access the demonstration page through the EdgeOne domain. Although the page itself is static, it provides a simple representation of the 1st Course project and its main features.
The deployment process was not completely smooth on my first attempt. The initial deployment returned a 404 error even though the build process had completed successfully. After investigating the problem, I found that the static deployment needed an appropriate entry page that could be served by the platform. I then added an index.html file to the public directory, committed the change, and pushed it to GitHub. After starting a new deployment using the latest commit, the website was successfully deployed.
This small problem became one of the most useful parts of the experiment. It reminded me that a successful build does not necessarily mean that the final website will work correctly. Developers still need to test the actual deployment and understand what files and resources are being served.
Technical Lessons Learned
There are several lessons I gained from this experience. The first is that developers need to understand their application's architecture before deciding how and where it should be deployed. Laravel applications that depend on PHP and MySQL have different requirements from static HTML websites.
The second lesson is the importance of GitHub in the development workflow. Keeping the project in a Git repository makes it easier to track changes, maintain different versions, and connect the source code to deployment services.
The third lesson is that deployment should always be tested from the user's perspective. A successful build message is useful, but it does not guarantee that the deployed website is accessible or functioning correctly. Checking the deployed URL and reading deployment logs are important parts of the process.
Finally, deployment errors should not immediately be considered failures. The 404 problem I encountered helped me understand the relationship between the project structure and the files required by a static deployment environment. Solving a real problem gave me a better understanding than simply following a tutorial where everything works on the first attempt.
Why This Experience Matters to Me
As a fresh graduate, I am still developing my understanding of the software development lifecycle. My experience with Tencent EdgeOne Makers showed me that being a web developer involves more than creating application features. Developers also need to understand source control, deployment, hosting, debugging, and the technical requirements of different environments.
This challenge also encouraged me to experiment with a project that I had already built instead of creating a completely separate demonstration project. As a result, the deployment process became more meaningful because I could directly connect what I learned with an application that I had developed myself.
Conclusion
The 1st Course project started as an academic project designed to solve problems related to student and financial management in a tutoring institution. Through the Tencent EdgeOne Makers challenge, I was able to take the project into another stage by experimenting with a real deployment workflow.
The most important lesson I gained is that deployment architecture must match the requirements of the application. The complete 1st Course system requires a PHP and MySQL environment because of its dynamic Laravel features, while a static demonstration can be deployed separately through a static web delivery platform.
For young developers, I believe one of the best ways to learn deployment is to actually try it. Connect a real project, configure the environment, deploy it, encounter problems, read the logs, and solve them. The experience of solving those problems can provide valuable knowledge that cannot always be gained from theory alone.
My experience with Tencent EdgeOne Makers was therefore not only about successfully deploying a web page. It was also an opportunity to better understand what happens between writing code and making a project accessible to users.
#TencentEdgeOne #EdgeOneMakers #CODEPOLITAN #EdgeOne
Top comments (0)