LearnPython.gr did not begin as a business plan or an attempt to create another programming education platform. Its starting point was far more personal.
I wanted to introduce my ten year old son to programming, and I believed Python was one of the best languages for his first experience. Its syntax is relatively clear, it allows beginners to see results quickly, and it is used across real fields ranging from web development and automation to data analysis and artificial intelligence.
While searching for material in Greek, I found individual videos, fragmented tutorials, and several useful resources. What I could not find was a complete experience. I was looking for an environment that could guide a beginner step by step, allow them to write and execute code without complicated installation, and provide immediate help when something did not work.
For an adult with previous technical experience, installing Python, configuring an editor, and understanding a terminal may simply be part of the learning process. For a child or an absolute beginner, however, those initial obstacles can shift attention away from the real objective, which is understanding the logic of programming.
Instead of continuing to search for the tool I had in mind, I decided to try to build it.
Creating LearnPython.gr
LearnPython.gr was initially designed as a completely Greek and free platform for learning Python. Its philosophy was straightforward. Users should not need to install software, understand how a development environment works, or determine the correct order of lessons by themselves.
The experience needed to begin with fundamental concepts and develop gradually. Variables, data types, conditions, loops, functions, and data structures had to be explained clearly, without treating the learner as a passive reader.
From the beginning, I wanted every lesson to connect with practical application. Theory alone is not enough to learn programming. Understanding develops when the learner writes code, makes a mistake, sees the result, changes something, and tries again.
This was why browser based code execution became a central part of the project. A user could read about a concept and immediately experiment with it without leaving the page or opening an external application.
LearnPython.gr gradually evolved from a collection of lessons into a real interactive learning environment.
Turning the browser into a learning laboratory
One of the main problems I wanted to solve was the distance between theory and practice. On many educational platforms, learners watch a video or read a chapter and then need to open a different application to test what they have learned.
This change of environment creates friction. The learner must remember the example, copy the code, manage files, and determine whether an error comes from the exercise or from the local installation.
In LearnPython.gr, the browser needed to function as a complete learning space. The lesson, editor, code execution, and feedback had to exist inside the same experience.
This approach does not remove the need for learners to eventually use a real development environment. It places that difficulty at the appropriate point in their journey. They can first understand the fundamental principles and later move to local tools, terminals, package managers, and more advanced development workflows.
For me, this was an important product decision. The platform did not simply need more features. It needed to remove obstacles that provided no educational value during a learner’s first steps.
From LearnPython.gr to LearnPython.ai
As the project matured, it became clear that the problem it was addressing was not limited to the Greek language. Beginners everywhere face similar difficulties. They do not know where to begin, error messages feel intimidating, and many give up when there is nobody available to explain what went wrong.
The move to LearnPython.ai represented more than a new name and domain. It was the point at which the project opened to an international audience and artificial intelligence became a central part of the learning experience.
The platform became bilingual, supporting both Greek and English, while its design began to focus more strongly on personal guidance for each learner.
The objective was not to place a generic chatbot in the corner of a page. I wanted the AI Tutor to understand the lesson context, the code being written, and the learner’s current level. Its assistance needed to relate to the specific moment of learning rather than exist as a disconnected conversation.
An AI Tutor that guides without replacing thought
Using artificial intelligence in education creates an important challenge. When a learner can simply request the final solution, they may complete exercises without understanding how the code actually works.
For that reason, the Personal AI Tutor was designed to act more like a guide and less like an answer generating machine.
It can explain a concept in another way, analyse an error, help the user identify where the problem is located, and create additional exercises adapted to their level. It can also generate quizzes and transform theory into smaller, more manageable challenges.
The real value is not that the AI knows the answer. It is that assistance can be available at the exact moment a question appears. In a traditional course, a student may need to wait until the next class to ask for help. In an online environment, the same delay can lead them to abandon the lesson entirely.
The AI Tutor attempts to close that gap by offering immediate support without removing the need for personal effort.
Personalised learning with the learner’s own material
Another step in the platform’s development was the ability to use personal files as educational context.
Learners can use their own notes, PDF files, or other material, allowing the AI to assist them based on the content they are already studying. The platform is therefore not limited exclusively to its built in courses. It can also support material from a school, university, book, or personal collection of notes.
Privacy was an important part of this functionality. File processing was designed to take place locally in the browser, reducing the need to transfer complete personal educational documents to an external server.
This decision had both technical and philosophical significance. Educational applications can become more personal without necessarily collecting more data than they genuinely need.
Learning as a continuous journey
Completing a course depends on more than the quality of its content. It also depends on whether the learner feels that progress is being made.
For this reason, the platform introduced progress tracking, challenges, badges, quizzes, and different forms of practical exercise. These elements were not intended to turn learning into a superficial game. Their purpose was to make development visible.
When someone begins programming, they often compare their limited knowledge with the entire technology field. The distance appears enormous. Structured progression helps learners focus on their next step rather than becoming discouraged by everything they do not yet know.
The platform also began expanding beyond the most fundamental Python concepts. Learning paths could lead towards libraries such as NumPy, Pandas, and Matplotlib, as well as introductory web development with Flask or Django.
The experience was not supposed to end as soon as users understood a loop or a function. They needed to see how those same foundations connect with real areas of application.
The moment when Python was no longer enough
As the project expanded, it raised a new question. If the central idea was to create a more accessible, interactive, and personal learning environment, why should it remain limited exclusively to Python?
Adding a complete JavaScript learning path changed the identity of the product. Python remained an important part of the platform, but the LearnPython.ai name could no longer describe the complete vision.
This change involved more than adding content. JavaScript has a different execution model, ecosystem, and relationship with the browser. The platform needed to support multiple learning paths without losing the consistency of the experience.
Shared functionality such as accounts, progress, exercises, and the AI Tutor needed to remain unified, while each programming language required its own educational context.
At that point, it became clear that the project was no longer evolving as a Python learning platform. It was becoming a broader ecosystem for people who wanted to learn software development.
Creating DevApps Learn
DevApps Learn emerged as the natural continuation of that evolution.
The new identity no longer connects the platform to a single language. It provides space for Python, JavaScript, and any additional learning path that may be introduced in the future.
Moving from LearnPython.ai to DevApps Learn was not simply a rebranding exercise. It required a change in product architecture and in the way the experience was organised.
The original platform could assume that most users followed approximately the same path. In DevApps Learn, each person may have a different objective. One learner may begin with Python for automation. Another may be interested in web development with JavaScript. A third may use the platform as a companion for university notes.
The product therefore needed to become more flexible without becoming more complicated.
Its central promise remained unchanged. Learners can begin without installation, write code inside the browser, receive immediate feedback, and request personal guidance whenever they need it.
The platform’s technical evolution
Across different stages of development, the project used technologies including React, Firebase, Firestore, Firebase Hosting, Tailwind CSS, the Gemini API, and browser based solutions for code execution and local data handling.
React supported the development of a dynamic interface with reusable components and multiple interactive states. Firebase provided services for data storage, user progression, and application hosting.
The Gemini API made the development of the AI Tutor possible, but the real challenge was not simply connecting the application to a language model. The correct context had to be designed, irrelevant responses needed to be reduced, and the AI had to connect with the lesson, the learner’s code, and their current actions.
The browser based editor and code execution environment introduced further technical requirements. The platform needed to manage editor state, execution results, errors, and environment resets without making the experience slow or unstable.
As more languages and features were introduced, the most important technical requirement became the creation of a common foundation that could continue to expand. DevApps Learn needed to support new lessons, exercises, and functionality without requiring the entire application to be redesigned for every addition.
Keeping the core learning experience free
Accessibility has remained one of the central principles of the project since its first version.
The fundamental lessons and practical learning experience should not sit behind a high financial barrier. A student, parent, or person considering a career change should be able to explore programming and build meaningful foundations without making a commitment on the first day.
The platform keeps its core educational content free, while more advanced AI functionality can be supported through an optional low cost subscription.
Achieving this balance is difficult. AI services have a real operational cost, and maintaining a platform requires continuous work. At the same time, I did not want the project to lose the reason it originally existed.
LearnPython.gr was created because an accessible option was missing. DevApps Learn needs to continue being that option.
What I learned through the different versions
The journey from LearnPython.gr to LearnPython.ai and eventually DevApps Learn taught me that a real product does not evolve simply because new features are added.
Sometimes the entire framework through which the project is understood needs to change.
LearnPython.gr attempted to address a specific gap for Greek learners. LearnPython.ai opened that experience internationally and introduced personal AI guidance. DevApps Learn is an effort to bring those elements together inside a shared platform that is not limited to a single programming language.
At every stage, I needed to reconsider decisions that had once appeared final. Navigation structure, progress storage, the relationship between lessons and the editor, the behaviour of the AI Tutor, and even the identity of the product itself all needed to evolve.
I also learned that internationalisation is not simply the translation of text. Content needs to remain natural and understandable in every language. Examples, instructions, errors, and AI communication must follow the same educational tone.
Most importantly, I learned that technology cannot replace clear educational thinking. An impressive editor or a powerful AI model provides limited value when learners do not understand what their next step is or why they should take it.
The project as a personal journey
DevApps Learn is more than a technical portfolio project for me.
It connects my role as a father, my professional experience in IT, my continued development as a software developer, and my desire to create tools that solve real problems.
It began with the intention of helping one child write his first lines of code. It gradually became a platform that can be used by learners of different ages, languages, and levels of experience.
The journey was not linear. It included name changes, new architectural requirements, redesigned features, and several occasions where an initial idea needed to be abandoned or rebuilt.
That is also the part of software development I find most creative. A project is not complete when it works for the first time. It matures when its purpose and audience become clearer.
The next chapter
DevApps Learn has now created the foundation for something broader than its original idea.
Python and JavaScript can become the beginning of a larger collection of learning paths. The AI Tutor can become more personal by understanding each learner’s progress, difficulties, and learning patterns. Exercises can adapt dynamically, while personal educational material can become more closely connected with the platform’s structured courses.
Development must remain careful, however. More functionality does not automatically create a better experience. Every new feature should respond to a genuine educational need rather than turn the platform into a complicated collection of tools.
The objective remains the same as it was on the first day. Someone should be able to open a browser, begin without fear, and develop the confidence that they are capable of understanding and creating software.
Final thoughts
The move from LearnPython.gr to LearnPython.ai and then to DevApps Learn was not simply a sequence of name changes.
It was the evolution of an idea.
At first, the question was how a child could learn Python in Greek without becoming lost in installations, fragmented tutorials, and technical complexity.
The question later became how a learner anywhere in the world could receive immediate, personal assistance at the moment it was needed.
Today, the question is broader. How can an environment be created in which different people, with different goals and different levels of experience, can learn programming in a practical, personal, and accessible way?
DevApps Learn is my attempt to answer that question.
It is not simply the new name of LearnPython. It is the next stage of a project that began with a family moment and developed into an open vision for making programming education more human, interactive, and available to everyone.