Any technical project that lives long enough inevitably ends up reflecting the evolution of technologies, the developer's experience, and the initial goals. ludoprogramming.com is not just a technical blog, but also a real journal of architectural decisions, successful (and less successful) experiments, and continuous adaptation.
This article chronologically follows the transformations the site has undergone, from the first lines of code written in Web Forms to the discussion about a possible future based on Azure Functions and a service-oriented architecture.
1. Beginnings: ASP.NET Web Forms + .NET Framework + SQL Server
The first version of the site was built using:
-
ASP.NET Web Forms
-
.NET Framework
-
SQL Server as the database
At that time, Web Forms offered a quick way to build dynamic web applications, with a relatively small learning curve. The event-based model and server-side controls were suitable at first, but came with:
-
logic strongly tied to the UI
-
testing difficulties
-
limited control over the generated HTML
This stage was essential for laying the foundation, but also for understanding the limitations that arise in projects that grow over time.
2. Transition to .NET Core and Azure Web App
The next natural step was migrating to:
-
ASP.NET Core
-
Azure Web App for hosting
This move brought clear benefits:
-
better performance
-
modern configuration (native dependency injection)
-
clearer separation of responsibilities
-
easy integration with the Azure ecosystem
The site became more stable, easier to maintain, and ready for expansion.
3. Bootstrap, MySQL, and moving to Ubuntu VM in Azure
As the project matured, other important changes appeared:
UI & Design
-
applying a Bootstrap theme for a modern and responsive look
Backend & infrastructure
-
migration from SQL Server to MySQL
-
deployment on Ubuntu VM in Azure
-
configuration of Nginx as the main server
-
Apache kept as entry point, with redirect to Nginx
This stage was deeply technical, focused on:
-
understanding Linux server administration
-
proper configuration of the reverse proxy
-
full control over the runtime environment
It was an important step from "platform as a service" to "infrastructure as a service".
4. Experiment: Blazor WebAssembly
Out of the desire to learn and experiment with modern technologies from the .NET ecosystem, the site was refactored into a version based on:
-
Blazor WebAssembly
-
a new Bootstrap theme
The goal of this stage was not necessarily production, but:
-
understanding the SPA model in .NET
-
analyzing the development experience with Blazor
-
testing performance and flexibility
Quick conclusion
For a content-oriented blog, the major issue was SEO:
-
client-side rendering
-
poor indexing in search engines
-
longer time until content display
Although Blazor is an excellent technology in certain contexts, for this use case it was not the optimal choice.
5. Return to MVC + API (with lessons learned)
After the Blazor experiment, the decision was pragmatic:
-
return to ASP.NET MVC for UI
-
separate API for logic and data
-
keeping the same Bootstrap theme
This architecture offered:
-
excellent SEO
-
clear separation between presentation and backend
-
possibility to extend the API for other clients (mobile, MAUI, SPA)
Practically, the site became more mature and closer to a real product, not just an experiment.
6. What could be the next step?
Web App for UI + Azure Functions for backend
A natural step in the project's evolution could be:
-
Web App (MVC or even Razor Pages) strictly for UI
-
replacing the classic API with Azure Functions
Benefits
-
serverless architecture
-
automatic scaling
-
optimized costs
-
small, well-defined functions (articles, comments, search, admin)
Practically
-
UI → Azure Web App
-
Backend → Azure Functions (HTTP triggered)
-
possible transition to a light microservices architecture
This approach would transform ludoprogramming.com into a real example of modern architecture, perfectly aligned with the themes discussed on the blog.
Conclusion
The evolution of ludoprogramming.com is not about "rewriting code", but about:
-
continuous learning
-
adapting to context
-
making the right decisions for the application's purpose
Each stage had its role and contributed to the current level of maturity. The next step is not necessarily a radical change, but a refinement of the architecture — exactly how any healthy technical project should evolve.
