Here I describe nine technical areas I work in: backend engineering, infrastructure and networking, automation and DevOps, testing, data systems, security, reliability, infrastructure as code, and AI and LLM models. I don't treat them as separate specializations - a decision made in one area always has consequences in the others. For each area I show which production problems it involves, which tools I use, and why those in particular.
Table of contents
Backend engineering is not about "writing APIs" or implementing endpoints for me. It is an area where abstractions meet operational reality, and technical decisions made today have a direct impact on costs, stability, and the pace of system development over the years.
When designing a backend, I focus not on how quickly something will be created, but on how the system will behave under load, in error situations, and over a long lifecycle. The backend must be predictable, readable, and resilient to changes - both technological and organizational.
The backend is the backbone of the application. It:
Therefore, the following are crucial to me:
The backend cannot be a collection of random components - it must be a system that can be analyzed, developed, and maintained without losing control.
Every backend starts with architectural decisions:
Only in the next step do I choose technologies. Tools are a consequence of architecture, not its starting point.
PHP and Laravel
I treat PHP combined with Laravel as a stable platform for building application backends, especially where:
Laravel provides structure, conventions, and tools, but domain logic remains independent of the framework.
Python
I use Python where the backend:
Python works very well as:
In systems of growing complexity, asynchrony ceases to be an option and becomes a necessity.
RabbitMQ
I use RabbitMQ to:
Event queues allow:
PostgreSQL
I choose PostgreSQL where:
It is not just a data store, but an active element of the system architecture.
MariaDB
MariaDB works well in systems:
I use Redis as:
RediSearch
I treat RediSearch as a specialized Redis extension, enabling:
This solution works particularly well where:
I use Elasticsearch as:
I apply it where:
Elasticsearch is an element of specialized architecture, not a default choice.
Backends are very rarely closed systems. Therefore, I treat APIs as a contract, not an implementation detail.
I use:
Well-designed APIs:
Tests are a tool for verifying architecture for me, not just code correctness.
I use:
Testing is an integral element of backend design.
A good backend:
Therefore, my approach to backend engineering is based on:
Infrastructure & Networking is an area where technical decisions quickly materialize into real operational consequences. This is where abstract diagrams meet physical hardware, network constraints, failures, and maintenance costs. Well-designed infrastructure is invisible - it operates stably, predictably, and does not require constant attention. Poorly designed infrastructure becomes a bottleneck for the entire system.
When designing infrastructure, I do not focus on individual servers or devices, but on a coherent environment that supports backend system development, ensures data security, and enables scaling without the need for constant foundation rebuilding.
IT infrastructure is not the sum of servers, switches, and virtual machines. It is a system of dependencies where:
Every element must be designed in the context of the others. Isolated infrastructure decisions quickly lead to operational chaos.
MikroTik and the network layer
I use MikroTik devices as flexible and precise tools for:
MikroTik works well where:
OPNsense
I treat OPNsense as a central element for:
A firewall is not an addition to infrastructure - it is an active element of the system architecture.
KVM as the foundation
KVM is the base virtualization layer for me - stable, predictable, and well-integrated with the Linux ecosystem.
oVirt and Proxmox
I use oVirt in environments where:
Proxmox works well where:
In both cases, the following are crucial:
Docker
I treat Docker as:
Containerization simplifies operations, but does not replace architecture.
Kubernetes
I use Kubernetes where:
It is not a default solution - it is a tool for specific problems.
TrueNAS and QNAP
I treat storage systems as a critical infrastructure element:
Storage is not just a place for data - it is a guarantee of its integrity and availability.
Bacula
Bacula is used for:
Backup is an element of architecture, not a "just in case" procedure.
Nagios and Zabbix
I use infrastructure monitoring systems for:
Grafana
Grafana serves as a visual layer:
Monitoring makes sense only when it leads to action, not when it generates noise.
Graylog
I use Graylog for:
Logs are the memory of the system - without them, infrastructure is blind.
FreeIPA
FreeIPA serves as:
Consistent identity is the foundation of security and operational order.
I treat GitLab not as a "code repository", but as:
It is an infrastructure component that connects the development world with operations.
Well-designed infrastructure:
My approach to Infrastructure & Networking is based on:
Automation and DevOps are not a collection of tools or a separate "stage after development" for me. It is a way of thinking about system development and maintenance, where repeatability, predictability, and reduction of operational risk are key. Every process that must be performed manually more than once becomes a candidate for automation.
The goal of DevOps is not to speed up team work at all costs, but to reduce the cost of error, shorten response time, and eliminate dependencies on knowledge hidden in the heads of individuals.
I treat automation as an integral element of architecture, not a set of auxiliary scripts. A well-designed system:
DevOps begins at the system design stage, not at the moment of first deployment.
GitLab CI as a central element of pipelines
I treat GitLab as a process platform, not just a code repository. CI/CD serves as:
I design pipelines so that they:
Deployment automation makes no sense if it is not understandable.
Docker as a repeatability tool
I use Docker to:
A container is not an end in itself - it is packaging for architecture that enables its portability and scaling.
Kubernetes as a tool for mature systems
I use Kubernetes where:
It is not a default solution. Kubernetes makes sense only when:
Otherwise, it increases maintenance costs instead of reducing them.
Automation does not always require extensive platforms. In many cases:
are more effective than heavy orchestration solutions.
The key is that automation should be:
Automation without feedback is dangerous. Therefore, I always combine DevOps with:
Automated processes must:
DevOps is not about deploying faster than others. It is about:
Automation reduces dependence on individuals and increases organizational resilience to rotation, time pressure, and human errors.
Well-designed DevOps processes:
My approach to automation and DevOps is based on:
Testowanie nie jest dla mnie ostatnim etapem przed wdrożeniem ani „dodatkową kontrolą jakości". To stały element procesu wytwarzania oprogramowania, który łączy architekturę, implementację i wymagania biznesowe. Dobrze zaprojektowany zestaw testów pozwala bezpiecznie wprowadzać zmiany, skraca czas diagnozy problemów i zmniejsza koszt regresji.
Nie traktuję testów jako jednego narzędzia, lecz jako zestaw komplementarnych technik, które odpowiadają na różne pytania o zachowanie systemu — od poziomu pojedynczej funkcji, przez współpracę modułów, po pełne scenariusze biznesowe i niefunkcjonalne aspekty jakości.
Testowanie nie jest celem samym w sobie. Projektując system, zwracam uwagę na testowalność architektury (czyste kontrakty, separacja warstw), integrację testów z pipeline'ami CI/CD oraz dobranie poziomu automatyzacji do profilu ryzyka. Dzięki temu testy nie spowalniają pracy, lecz umożliwiają bezpieczne iterowanie nad systemem w długim horyzoncie czasu.
Data is one of the few elements of an information system whose loss or damage has real and often irreversible business consequences. Code can be recreated, infrastructure rebuilt, processes improved. Data - not always. Therefore, I treat data and storage systems as an area requiring special design and operational discipline.
When designing the data layer, I do not focus solely on performance or capacity. What is crucial to me is consistency, integrity, the ability to restore, and predictable behavior in failure situations.
Data is not merely the result of system operation - it is its memory. Their structure, location, and storage method directly affect:
Therefore, I start designing data systems by:
PostgreSQL
I choose PostgreSQL where:
I treat PostgreSQL as:
MariaDB
MariaDB works well in systems:
In both cases, data schema design is an integral part of the architecture, not a side effect of implementation.
Redis
I use Redis as:
Redis allows reducing the load on persistent storage systems while providing very low latency.
RediSearch
I use RediSearch where:
This is a specialized solution, used consciously and purposefully.
Elasticsearch
I use Elasticsearch as:
It does not replace the relational database, but complements the architecture where requirements exceed its natural capabilities.
ZFS as the foundation of reliability
I treat ZFS as a file system and volume manager that:
ZFS allows building storage systems resistant to errors and ready for long-term use.
TrueNAS and QNAP
I use TrueNAS in environments requiring full control, high performance, and advanced ZFS mechanisms.
QNAP works well where functionality, quick deployment, and integration with existing infrastructure are important.
Storage is not just a "place for data" - it is an active element of security strategy.
Bacula
I use Bacula for:
Backup makes no sense without:
I design data systems so that:
Snapshots, replication, and environment separation are risk management tools, not additions.
Well-designed data systems:
My approach to data and storage systems is based on:
Security and access control are not about "blocking everything possible". Their goal is to precisely determine who has access to what and in what context, while maintaining the smooth operation of systems and people. Poorly designed security mechanisms generate workarounds, frustration, and operational chaos. Well-designed ones are largely invisible.
When designing the security layer, I assume that access is one of the key elements of system architecture, not a separate configuration added at the end.
The fundamental question is not "how to secure", but "who is the user or system". Only on this basis can permissions be meaningfully enforced.
Identity centralization:
Without a consistent identity model, security becomes a collection of exceptions.
I treat LDAP as the backbone of the identity system, not just a user directory.
FreeIPA
I use FreeIPA as:
This allows:
LDAP in this model is not an "integration" - it is the source of truth about identity.
I design permissions based on:
Roles are not random - they reflect:
Thanks to this:
I integrate backend applications with LDAP / FreeIPA in a way that:
I use models:
Access control does not end at the application.
Network segmentation
Network segmentation allows:
Firewalls and VPN
I treat firewalls and VPN as:
Administrative access:
Security concerns not only people, but also services.
When designing system-to-system access:
Each integration:
Security is not a state - it is a process.
Therefore:
LDAP / FreeIPA enables:
A well-designed access control system:
My approach to security and access control is based on:
Operational scalability and reliability are not features that are "added" to a system after its construction is completed. They are a consequence of decisions made at every stage of design, from backend architecture, through infrastructure, to operational processes. A system that works only under ideal conditions is not, in practice, a production system.
When designing solutions, I assume that failures, load growth, and organizational changes are inevitable. The question is not "if", but "when" and "how the system will react to it".
Scalability does not mean only handling more traffic. It is the system's ability to:
An operationally scalable system:
One of the key elements of reliability is limiting mutual dependencies.
I use:
Thanks to this:
I design systems assuming that:
I achieve resilience through:
Reliability is not about the absence of failures, but about the ability to quickly return to a stable state.
The choice of scaling strategy depends on the nature of the system.
I use vertical scaling where:
I use horizontal scaling where:
The key is conscious management of compromises.
You cannot manage what you cannot see.
Operational scalability requires:
Thanks to observability:
Even the best-designed system loses value without appropriate processes.
Therefore, I pay attention to:
Systems must be prepared not only for traffic growth, but also for:
For the end user, reliability:
Every system downtime:
Therefore, I treat reliability as a strategic parameter, not a technical detail.
Systems designed with scalability and reliability in mind:
My approach is based on:
Infrastructure as Code (IaC) is not for me a collection of scripts or "config in a repo". It is a way of defining and managing infrastructure so that it is repeatable, versioned, and auditable - and so that it directly supports automation, reliability, and cost control. Where environments are built from code, infrastructure becomes part of the system architecture, not a set of manual server changes.
I use IaC where deployment predictability, environment reproducibility (including for LLM models in a closed infrastructure), and reduction of configuration drift matter. Infrastructure described as code enables change review, rollback, and clear audit - which translates into lower operational risk and faster response to failures.
I treat Infrastructure as Code as an integral part of the project, not a stage "after deploying the application". Well-designed infrastructure in code:
IaC connects directly with automation and DevOps: the pipeline builds and deploys not only the application but also the infrastructure on which it runs.
Environments defined in code:
As a result, infrastructure for critical applications - including closed infrastructure for LLM models - is predictable in terms of cost and deployment time.
Infrastructure changes in the repository:
This reduces operational risk and makes team collaboration easier - infrastructure is no longer "tribal knowledge" held by a single person.
I use IaC consistently where:
In LLM scenarios, Infrastructure as Code is the foundation for data and cost control - the environment is defined, versioned, and reproducible without relying on manual steps.
I use established IaC tools (e.g. Terraform, Ansible) depending on context: cloud, on-premises servers, containers. What matters is not the tool itself but:
IaC only makes sense when it is kept up to date - otherwise code and actual infrastructure state drift apart and the benefits disappear.
An IaC-based approach:
My approach to Infrastructure as Code is based on:
Artificial intelligence and language models (LLM) are not for me a tool for experiments or a way to use trendy technologies. They are an element of system architecture that must be designed with real business value for the applications it runs in mind. I use public LLM models in a closed infrastructure, which ensures data control, cost predictability, and long-term solution stability.
When designing AI solutions, I focus not on quick deployment, but on how the system will deliver business value, what costs it will generate, and how it will protect data. AI must be predictable, controlled, and resilient to changes - both technological and business.
LLM models are not a separate component that is "added" to the system. They are an integral part of architecture that:
Therefore, the following are crucial to me:
AI cannot be a dependence on external providers without control - it must be an element of the system that can be controlled, developed, and maintained without losing autonomy.
I use public LLM models in a closed infrastructure, which brings real advantages in enterprise projects:
Using LLM models in a closed infrastructure requires infrastructure that is predictable, scalable, and controlled. Therefore, I use Infrastructure as Code (IaC) to manage AI environments:
IaC for AI is not just automation - it is the foundation of predictability and control over costs and performance of AI systems.
The main domain of my AI work is using models to deliver real business value in applications. It's not about experimenting with trendy technologies, but about:
Every AI solution I design must have a clearly defined business value for the application it runs in. AI is not an end in itself - it is a tool for achieving business goals.
AI solutions I design directly support three pillars of stable IT projects:
PILLAR 1 - Project Predictability: Using public LLM models in a closed infrastructure and IaC ensure cost and performance predictability, eliminating dependence on variable API prices and provider limits. IaC infrastructure enables precise cost and deployment time estimates.
PILLAR 2 - Technological Risk Reduction: Closed infrastructure for LLM models eliminates the risk of dependence on external API providers, provider policy changes, or loss of access. IaC ensures environment reproducibility and operational risk reduction.
PILLAR 3 - Impact on Margin: Control over AI infrastructure costs and lack of dependence on variable API prices protect project margins. Automation through IaC reduces operational costs and minimizes the need for manual intervention. Business value delivered by AI should improve the project margin, not burden it.
AI should protect margin, not consume it. Using public LLM models in a closed infrastructure and IaC is the foundation of control over costs and business value.
Building infrastructure for LLM models and using IaC requires capital investment, but it is an investment that pays off in the form of:
AI is not an end in itself. It is a tool that must support three pillars of stable IT projects: predictability, risk reduction, and impact on margin, while delivering real business value.