Readme
Real-world example of a modern Slim 4 web application with a scalable structure and a variety of components and features.
Current best practices and programming principles are applied throughout the project.
Adhering to the Single Responsibility Principle
(SRP)
is a key focus.
External library dependencies are kept to a minimum
to facilitate maintenance and ensure long-term viability.
The architecture is inspired by the Domain Driven Design (DDD) and the Vertical Slice Architecture.
The base for this project was the official Slim-Skeleton and the slim4-skeleton.
A detailed documentation explains how the project is built, components, design choices and features.
Stripped down versions of this repository are available as skeleton templates. With frontend slim-starter or just for an API: slim-api-starter.
Please read the installation guide to get started.
All the features were developed with an effort to ensure maximum user-friendliness. The frontend, intuitive, aesthetically pleasing, minimalistic, and functional. The backend, efficient and secure.
This project is currently designed for non-profit organizations or foundations that require a platform to manage and maintain a record of communication through notes of people they help.
Project components:
- Dependency Injection
- Session and flash messages
- Authentication (login) and authorization (permissions)
- Account verification and password reset via email link and token
- Request throttling - protection against brute force and password spraying attacks (time throttling and captcha)
- Localization - English, German and French
- Input validation
- Template rendering with native PHP syntax (easily interchangeable with twig)
- Dark theme
- Error handling
- Integration & unit testing
- Database migrations and seeding
- Query Builder
- Logging
- Mailing
- Simple console commands
- Scrutinizer
- GitHub Actions
Functionalities demonstrating real-world features:
- User management for administrators
- 4 user roles and different permissions
- User activity history
- Client creation and mutation with status and attributed user
- Client list filtering by text input and filter chips
- Note creation and mutation
- Hidden notes from unauthorized users
- Dashboard with panels
Click to see demo
Link: Login
Username: admin@user.com
Password: 12345678
The database is regularly reset.
There is a ton of great content on the internet about learning how to write clean and sustainable code. However, I found myself searching for more than just skeleton projects or general documentations and tutorials when I wanted to learn how to do things within the scope of a potential real-world application. I never found resources such as an open-source, efficient implementation of all the features surrounding a full-sized project.
This is what I try to provide here. This project isn't just a skeleton, it contains a lot of opinionated practical examples on how to implement features that are often needed in real-world applications.
That includes authorization, integration testing, localization, validation, error handling, database migrations, mailing, console commands, request throttling, lightweight PHP template rendering, GitHub Actions, and more along with detailed explanations in the documentation.
But it's not just about the features. Equally important is the architecture and how the components interact with each other, following modern principles such as the Single Responsibility Principle and Dependency Injection.
Of course, there are big frameworks that have their own well-established set of programming conventions and implementations of features.
However, I find them often
too complex, where the code makes too much "behind the scenes" and with lots of dependencies,
which can lead to time-consuming refactoring on version changes.
I also dislike having to follow the propitiatory rules of a framework which often don't
follow best practices
and much prefer the freedom of a micro-framework and carefully
choosing the libraries and structure
that make sense for the project.
This lets me stay in control of the codebase, keep it lightweight,
performant and tailored to the needs of the project, and it's easier to maintain
and adapt to new requirements.
This project and its documentation are the result of my personal learning process in the last 6 years
in trying to create the best possible template app with lots of real world examples.
Three of the 6 years were spent full time on this project alone.
I made what wish I had when I started getting seriously into web development.
The codebase is big and thus lots of subjective decisions had to be made that may not be the best long-term solution for everybody.
The main focus throughout the development was to make the code as long living as possible with best practices and few dependencies so that it can be adapted to different needs and preferences.
Basically, this is my take on what an efficient, extensible, and maintainable web app could look like with today's tech.
I worked closely with the software engineer and architect Daniel Opitz, who also reviewed this project. I learned a lot during our exchanges and was inspired by his books, articles, tutorials and his slim skeleton-project.
Please read the Support❤️ page if you value this project and its documentation and want to support it.
This project is licensed under the MIT License — see the LICENSE file for details.