Technologies

Backend, infrastructure, automation, security, data and AI - technical competencies that form one coherent system

27 min read

Scroll down

Technologies

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.

Backend as the foundation of the system

The backend is the backbone of the application. It:

  • stores and protects data,
  • enforces business rules,
  • ensures consistency and predictable operation,
  • integrates with other systems and services.

Therefore, the following are crucial to me:

  • readable code structure,
  • clear responsibility boundaries,
  • controlled data flow,
  • conscious state and error management.

The backend cannot be a collection of random components - it must be a system that can be analyzed, developed, and maintained without losing control.

Backend design as a decision-making process

Every backend starts with architectural decisions:

  • where responsibility boundaries lie,
  • which elements must be synchronous and which asynchronous,
  • which data is operationally critical,
  • how the system should respond to overloads and failures.

Only in the next step do I choose technologies. Tools are a consequence of architecture, not its starting point.

PHP, Python and the application layer

PHP and Laravel

I treat PHP combined with Laravel as a stable platform for building application backends, especially where:

  • code readability and predictability are important,
  • the system has a long lifecycle,
  • rapid iteration while maintaining quality is crucial.

Laravel provides structure, conventions, and tools, but domain logic remains independent of the framework.

Python

I use Python where the backend:

  • serves as a data processing layer,
  • performs analytical or automation tasks,
  • handles asynchronous or auxiliary processes.

Python works very well as:

  • an event processing component,
  • a system integration tool,
  • a backend for specialized services.

Asynchronous communication and event queues

In systems of growing complexity, asynchrony ceases to be an option and becomes a necessity.

RabbitMQ

I use RabbitMQ to:

  • separate responsibilities between components,
  • handle long-running processes,
  • buffer loads,
  • stabilize the system during traffic spikes.

Event queues allow:

  • decoupling the pace of individual components,
  • increasing error resilience,
  • designing the system in a modular way.

Databases as an element of architecture

PostgreSQL

I choose PostgreSQL where:

  • data consistency is crucial,
  • complex relationships occur,
  • solid transactional mechanisms are required,
  • the system must be predictable over the long term.

It is not just a data store, but an active element of the system architecture.

MariaDB

MariaDB works well in systems:

  • with simpler data models,
  • with classic relational schemas,
  • where performance and simplicity matter.

Redis, RediSearch and performance control

I use Redis as:

  • application cache,
  • temporary data storage,
  • a state synchronization mechanism,
  • support for horizontal scaling.

RediSearch

I treat RediSearch as a specialized Redis extension, enabling:

  • fast full-text search,
  • in-memory data filtering,
  • advanced queries without burdening the relational database.

This solution works particularly well where:

  • low latency matters,
  • data is frequently read,
  • search is a critical element for UX or operational processes.

Elasticsearch and search

I use Elasticsearch as:

  • a search engine,
  • a data analysis tool,
  • a layer for working with large volumes of information.

I apply it where:

  • relational databases cease to be optimal,
  • fast searching and aggregations are needed,
  • data has a semi-structured nature.

Elasticsearch is an element of specialized architecture, not a default choice.

API as a system contract

Backends are very rarely closed systems. Therefore, I treat APIs as a contract, not an implementation detail.

I use:

  • REST as a clear communication model,
  • OpenAPI for documenting interfaces,
  • consistent versioning,
  • unambiguous error models.

Well-designed APIs:

  • reduce misunderstandings,
  • enable independent component development,
  • organize team collaboration.

Testing and verification of assumptions

Tests are a tool for verifying architecture for me, not just code correctness.

I use:

  • unit tests for isolated logic,
  • integration tests for communication between components,
  • scenarios reflecting real system usage.

Testing is an integral element of backend design.

Backend in a long-term perspective

A good backend:

  • scales without sudden changes,
  • does not block product development,
  • maintains predictability under load.

Therefore, my approach to backend engineering is based on:

  • architectural minimalism,
  • conscious technology selection,
  • resilience to changes,
  • thinking in terms of years, not sprints.

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.

Infrastructure as a system, not a collection of components

IT infrastructure is not the sum of servers, switches, and virtual machines. It is a system of dependencies where:

  • the network determines communication topology,
  • virtualization defines resource flexibility,
  • storage affects performance and security,
  • monitoring determines response time to problems.

Every element must be designed in the context of the others. Isolated infrastructure decisions quickly lead to operational chaos.

Network as the foundation of communication

MikroTik and the network layer

I use MikroTik devices as flexible and precise tools for:

  • building network segmentation,
  • traffic control,
  • managing routing and VLANs,
  • implementing access policies.

MikroTik works well where:

  • full traffic control is needed,
  • network topology evolves with systems,
  • configuration transparency is important.

OPNsense

I treat OPNsense as a central element for:

  • environment separation,
  • access control,
  • VPN handling,
  • security policy enforcement.

A firewall is not an addition to infrastructure - it is an active element of the system architecture.

Virtualization and resource management

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:

  • central orchestration is important,
  • cluster management must be consistent,
  • infrastructure is long-term and stable.

Proxmox works well where:

  • flexibility is needed,
  • environments change quickly,
  • machine and container virtualization are combined.

In both cases, the following are crucial:

  • conscious resource management,
  • environment isolation,
  • predictable behavior under load.

Containerization and orchestration

Docker

I treat Docker as:

  • a tool for standardizing environments,
  • a way to achieve deployment repeatability,
  • an element of CI/CD pipelines.

Containerization simplifies operations, but does not replace architecture.

Kubernetes

I use Kubernetes where:

  • system scale justifies additional complexity,
  • high SLA is required,
  • automation of service lifecycle management is important.

It is not a default solution - it is a tool for specific problems.

Storage and data security

TrueNAS and QNAP

I treat storage systems as a critical infrastructure element:

  • TrueNAS in environments requiring control, performance, and advanced ZFS mechanisms,
  • QNAP where functionality, simplicity, and integration with existing processes are important.

Storage is not just a place for data - it is a guarantee of its integrity and availability.

Backup and business continuity

Bacula

Bacula is used for:

  • central backup management,
  • data versioning,
  • implementing backup policies aligned with real failure scenarios.

Backup is an element of architecture, not a "just in case" procedure.

Monitoring and observability

Nagios and Zabbix

I use infrastructure monitoring systems for:

  • availability control,
  • resource monitoring,
  • rapid anomaly detection.

Grafana

Grafana serves as a visual layer:

  • aggregates data,
  • enables trend analysis,
  • supports operational decision-making.

Monitoring makes sense only when it leads to action, not when it generates noise.

Log centralization and event analysis

Graylog

I use Graylog for:

  • log centralization,
  • event correlation,
  • incident analysis.

Logs are the memory of the system - without them, infrastructure is blind.

Identity and access control

FreeIPA

FreeIPA serves as:

  • a central identity system,
  • user and permission management,
  • infrastructure service integration.

Consistent identity is the foundation of security and operational order.

GitLab as an infrastructure element

I treat GitLab not as a "code repository", but as:

  • a central CI/CD element,
  • a process integration point,
  • a tool organizing the software lifecycle.

It is an infrastructure component that connects the development world with operations.

Infrastructure in a long-term perspective

Well-designed infrastructure:

  • does not limit system development,
  • does not require constant rebuilding,
  • enables scaling without losing control,
  • supports organizational stability.

My approach to Infrastructure & Networking is based on:

  • minimizing complexity where it is not needed,
  • conscious tool selection,
  • architectural consistency,
  • thinking in terms of resilience, not just performance.

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.

Automation as an element of system architecture

I treat automation as an integral element of architecture, not a set of auxiliary scripts. A well-designed system:

  • can be reproduced in a repeatable manner,
  • behaves predictably regardless of environment,
  • minimizes differences between development, testing, and production.

DevOps begins at the system design stage, not at the moment of first deployment.

CI/CD as the backbone of the development process

GitLab CI as a central element of pipelines

I treat GitLab as a process platform, not just a code repository. CI/CD serves as:

  • an automatic quality validator,
  • a guardian of environment consistency,
  • a mechanism for enforcing standards.

I design pipelines so that they:

  • reflect the real application lifecycle,
  • clearly separate stages (build, test, deploy),
  • are readable and auditable.

Deployment automation makes no sense if it is not understandable.

Containerization and environment standardization

Docker as a repeatability tool

I use Docker to:

  • unify runtime environments,
  • eliminate "works on my machine" problems,
  • simplify build and deploy processes.

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:

  • scale justifies additional complexity,
  • high SLA is required,
  • the system consists of many independent components.

It is not a default solution. Kubernetes makes sense only when:

  • processes are already automated,
  • monitoring and logging are consistent,
  • the team understands operational consequences.

Otherwise, it increases maintenance costs instead of reducing them.

Operational automation and scripts

Automation does not always require extensive platforms. In many cases:

  • simple Bash scripts,
  • system tools,
  • clearly defined procedures,

are more effective than heavy orchestration solutions.

The key is that automation should be:

  • readable,
  • easy to modify,
  • well documented.

Monitoring, observability and feedback

Automation without feedback is dangerous. Therefore, I always combine DevOps with:

  • infrastructure monitoring,
  • application observability,
  • trend and anomaly analysis.

Automated processes must:

  • report their operation,
  • signal errors,
  • enable quick rollback of changes.

DevOps as risk reduction, not a speed race

DevOps is not about deploying faster than others. It is about:

  • deploying safely,
  • understanding the effects of changes,
  • having the ability to react quickly.

Automation reduces dependence on individuals and increases organizational resilience to rotation, time pressure, and human errors.

Automation in a long-term perspective

Well-designed DevOps processes:

  • do not require constant care,
  • do not escalate complexity with system growth,
  • support development instead of blocking it.

My approach to automation and DevOps is based on:

  • pragmatism instead of dogmas,
  • selecting tools for real problems,
  • gradual process evolution,
  • thinking in terms of operational resilience.

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.

Testy jednostkowe i integracyjne

  • Testy jednostkowe weryfikują krytyczną logikę domenową i kontrakty komponentów w izolacji, co pozwala wcześnie wyłapywać błędy i utrzymywać kod w ryzach.
  • Testy integracyjne sprawdzają współpracę modułów – np. backendu z bazą danych, kolejkami, usługami zewnętrznymi czy warstwą cache.

Testy end-to-end, funkcjonalne i regresyjne

  • Testy funkcjonalne / end-to-end odpowiadają na pytanie, czy kluczowe ścieżki biznesowe działają z perspektywy użytkownika i systemów zewnętrznych.
  • Testy regresyjne zapewniają, że nowe zmiany nie psują stabilnych obszarów systemu – szczególnie ważne przy długoterminowym utrzymaniu.
  • Testy smoke / sanity pozwalają szybko zweryfikować, czy środowisko po wdrożeniu jest w minimalnie działającym stanie.

Testy manualne, eksploracyjne i niefunkcjonalne

  • Testy manualne i eksploracyjne wykorzystuję tam, gdzie ważne są niestandardowe scenariusze, UX, kontekst domenowy lub trudno automatyzowalne przypadki brzegowe.
  • Testy wydajnościowe i obciążeniowe pozwalają sprawdzić, jak system zachowuje się pod realnym ruchem, spike'ami obciążenia czy długotrwałą pracą.
  • Testy bezpieczeństwa – od prostych kontroli uprawnień po scenariusze nadużyć – łączą się z warstwą bezpieczeństwa i monitoringu.

Testy jako element architektury i procesów

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 as an element of system architecture

Data is not merely the result of system operation - it is its memory. Their structure, location, and storage method directly affect:

  • application stability,
  • the possibility of analysis and functional development,
  • operational security,
  • maintenance costs.

Therefore, I start designing data systems by:

  • understanding the nature of data,
  • determining their lifecycle,
  • identifying critical and secondary data,
  • defining real failure scenarios.

Relational databases as the foundation of consistency

PostgreSQL

I choose PostgreSQL where:

  • data integrity is crucial,
  • complex relationships and transactions occur,
  • the system requires predictable behavior under load.

I treat PostgreSQL as:

  • a guardian of consistency,
  • an element of system logic,
  • an active component of architecture.

MariaDB

MariaDB works well in systems:

  • with simpler data models,
  • with classic relational schemas,
  • where stability and performance with less complexity are important.

In both cases, data schema design is an integral part of the architecture, not a side effect of implementation.

In-memory data and intermediate layers

Redis

I use Redis as:

  • application cache,
  • temporary data storage,
  • a state synchronization mechanism,
  • support for horizontal scaling.

Redis allows reducing the load on persistent storage systems while providing very low latency.

RediSearch

I use RediSearch where:

  • search is a critical element,
  • data must be filtered and searched in real-time,
  • loading the relational database would be unjustified.

This is a specialized solution, used consciously and purposefully.

Search and data analysis systems

Elasticsearch

I use Elasticsearch as:

  • a full-text search engine,
  • a tool for analyzing large data volumes,
  • a layer for working with semi-structured data.

It does not replace the relational database, but complements the architecture where requirements exceed its natural capabilities.

Data storage systems

ZFS as the foundation of reliability

I treat ZFS as a file system and volume manager that:

  • ensures data integrity,
  • enables snapshots and replication,
  • supports predictable space management.

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.

Backup and data recovery capability

Bacula

I use Bacula for:

  • central backup management,
  • data versioning,
  • implementing backup policies based on real failure scenarios.

Backup makes no sense without:

  • regular recovery tests,
  • clearly defined RPO and RTO points,
  • awareness of which data is truly critical.

Replication, snapshots and failure resilience

I design data systems so that:

  • failure of a single component does not mean data loss,
  • quick state restoration is possible,
  • operational risk is known and acceptable.

Snapshots, replication, and environment separation are risk management tools, not additions.

Data systems in a long-term perspective

Well-designed data systems:

  • do not require constant reorganization,
  • scale in a controlled manner,
  • support application development instead of blocking it.

My approach to data and storage systems is based on:

  • conscious technology selection,
  • minimizing data loss risk,
  • long-term predictability,
  • treating data as a strategic resource.

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.

Identity as the foundation of security

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:

  • reduces permission chaos,
  • simplifies management,
  • increases security,
  • enables auditing.

Without a consistent identity model, security becomes a collection of exceptions.

LDAP and FreeIPA as a central control point

I treat LDAP as the backbone of the identity system, not just a user directory.

FreeIPA

I use FreeIPA as:

  • a central directory of users and groups,
  • a permission management system,
  • an integration point for infrastructure and application services.

This allows:

  • defining access in one place,
  • enforcing security policies,
  • avoiding local accounts and distributed configurations.

LDAP in this model is not an "integration" - it is the source of truth about identity.

Access control as an element of architecture

I design permissions based on:

  • roles, not individuals,
  • minimum access scope (least privilege),
  • clear responsibility boundaries.

Roles are not random - they reflect:

  • function in the system,
  • operational responsibility,
  • usage context.

Thanks to this:

  • access can be easily modified,
  • personnel changes do not destabilize the system,
  • auditing is possible and clear.

Authorization in application systems

I integrate backend applications with LDAP / FreeIPA in a way that:

  • separates authorization logic from business logic,
  • enables central access management,
  • supports system development without accumulating technical debt.

I use models:

  • role-based access control (RBAC),
  • integration with LDAP as a source of roles and groups,
  • consistent mapping of roles to application permissions.

Infrastructure and network security

Access control does not end at the application.

Network segmentation

Network segmentation allows:

  • limiting the attack surface,
  • separating environments,
  • controlling traffic between components.

Firewalls and VPN

I treat firewalls and VPN as:

  • policy enforcement tools,
  • access control elements,
  • mechanisms for secure administrative access.

Administrative access:

  • is limited,
  • monitored,
  • auditable.

System-to-system access

Security concerns not only people, but also services.

When designing system-to-system access:

  • I avoid shared accounts,
  • I use unambiguous identifiers,
  • I limit the scope of permissions to a minimum.

Each integration:

  • has a clearly defined access scope,
  • is documented,
  • is subject to control and rotation of authentication data.

Audit, rotation and access hygiene

Security is not a state - it is a process.

Therefore:

  • access is regularly verified,
  • unused accounts are removed,
  • permissions are reviewed,
  • changes are recorded.

LDAP / FreeIPA enables:

  • central auditing,
  • change control,
  • policy consistency.

Security as an element of long-term stability

A well-designed access control system:

  • does not slow down work,
  • does not generate workarounds,
  • supports system development,
  • reduces the risk of incidents.

My approach to security and access control is based on:

  • identity centralization,
  • permission minimization,
  • architectural consistency,
  • treating security as an integral part of the system.

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 as an adaptation capability

Scalability does not mean only handling more traffic. It is the system's ability to:

  • adapt to changing requirements,
  • grow without radical rebuilding,
  • maintain predictable behavior.

An operationally scalable system:

  • allows adding resources without interfering with logic,
  • enables separating responsibilities between components,
  • does not require manual interventions with every change.

Separation of responsibilities and coupling reduction

One of the key elements of reliability is limiting mutual dependencies.

I use:

  • separation of services and components,
  • asynchronous communication where justified,
  • clear responsibility boundaries.

Thanks to this:

  • failure of one element does not destabilize the whole,
  • the system degrades in a controlled manner,
  • independent scaling of individual parts is possible.

Failure resilience as a design feature

I design systems assuming that:

  • components may stop responding,
  • the network may be unstable,
  • data may be temporarily unavailable.

I achieve resilience through:

  • redundancy of critical elements,
  • retry and timeout mechanisms,
  • flow control and back-pressure,
  • monitoring system behavior over time.

Reliability is not about the absence of failures, but about the ability to quickly return to a stable state.

Horizontal and vertical scaling in practice

The choice of scaling strategy depends on the nature of the system.

I use vertical scaling where:

  • the system is coherent and monolithic,
  • load growth is predictable,
  • the cost of simplifying architecture outweighs hardware costs.

I use horizontal scaling where:

  • components are stateless,
  • load is variable,
  • high availability is important.

The key is conscious management of compromises.

Observability as a condition of reliability

You cannot manage what you cannot see.

Operational scalability requires:

  • monitoring of resources and services,
  • trend analysis,
  • early anomaly detection.

Thanks to observability:

  • problems are detected before they become incidents,
  • decisions are based on data, not intuition,
  • continuous optimization is possible.

Operational processes and readiness for change

Even the best-designed system loses value without appropriate processes.

Therefore, I pay attention to:

  • automation of routine operations,
  • clear incident response procedures,
  • documentation of key decisions,
  • the ability to quickly restore operation.

Systems must be prepared not only for traffic growth, but also for:

  • team changes,
  • competency rotation,
  • time pressure.

Reliability as an element of trust

For the end user, reliability:

  • builds trust,
  • affects perceived quality,
  • has a direct impact on business value.

Every system downtime:

  • generates costs,
  • lowers credibility,
  • requires time to rebuild trust.

Therefore, I treat reliability as a strategic parameter, not a technical detail.

Scalability and reliability in a long-term perspective

Systems designed with scalability and reliability in mind:

  • better withstand growth pressure,
  • are cheaper to maintain in the long term,
  • enable development without continuous architectural revolutions.

My approach is based on:

  • systems thinking,
  • conscious selection of compromises,
  • designing for non-ideal conditions,
  • treating stability as an element of competitive advantage.

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.

IaC as an element of system architecture

I treat Infrastructure as Code as an integral part of the project, not a stage "after deploying the application". Well-designed infrastructure in code:

  • is repeatable across environments (dev, test, production),
  • can be verified in the code review process,
  • enables environment recovery in case of failure or provider change.

IaC connects directly with automation and DevOps: the pipeline builds and deploys not only the application but also the infrastructure on which it runs.

Repeatability and predictability

Environments defined in code:

  • eliminate "works on my machine, not in production" gaps,
  • shorten deployment time and reduce the risk of manual configuration errors,
  • make scaling easier - new instances are created from the same definition.

As a result, infrastructure for critical applications - including closed infrastructure for LLM models - is predictable in terms of cost and deployment time.

Versioning, review, and rollback

Infrastructure changes in the repository:

  • have history and an author,
  • can be reviewed before deployment,
  • allow reverting to a known state if issues arise.

This reduces operational risk and makes team collaboration easier - infrastructure is no longer "tribal knowledge" held by a single person.

Connection to automation and AI environments

I use IaC consistently where:

  • closed, controlled infrastructure is required (e.g. for public LLM models),
  • fast environment reproducibility is needed after failure or when scaling,
  • cost and deployment time predictability are important.

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.

Tools and discipline

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:

  • consistent infrastructure definition in the repository,
  • integration with CI/CD pipelines,
  • documentation and minimizing exceptions ("manual fixes" outside code).

IaC only makes sense when it is kept up to date - otherwise code and actual infrastructure state drift apart and the benefits disappear.

Infrastructure as Code in a long-term perspective

An IaC-based approach:

  • supports reliability and fast environment recovery,
  • reduces configuration drift and the risk of "forgotten" changes,
  • enables predictable cost and deployment time - including in projects with AI and closed infrastructure.

My approach to Infrastructure as Code is based on:

  • treating infrastructure as part of system architecture,
  • linking IaC with automation and DevOps,
  • versioning and auditing changes,
  • using IaC as a foundation for predictable environments, including for LLM models.

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.

AI as an element of system architecture

LLM models are not a separate component that is "added" to the system. They are an integral part of architecture that:

  • supports business processes in a predictable manner,
  • protects data through infrastructure control,
  • ensures long-term cost stability,
  • enables adaptation to specific needs of applications.

Therefore, the following are crucial to me:

  • using public LLM models in a closed infrastructure (control over data and costs),
  • IaC infrastructure for AI environments (predictability and scalability),
  • architecture supporting three pillars of stable IT projects,
  • conscious management of costs and technological margin.

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.

Public LLM models in closed infrastructure

I use public LLM models in a closed infrastructure, which brings real advantages in enterprise projects:

  • Data control – data does not leave the organization's infrastructure, which is crucial for security and compliance,
  • Cost predictability – no dependence on variable API prices, costs are controlled and predictable,
  • Provider independence – no risk of changes in provider policy, API availability, or limits,
  • Customization to needs – ability to fine-tune models for specific needs of applications,
  • Long-term stability – solution is not dependent on external API provider decisions.

IaC infrastructure for AI

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:

  • Automatic infrastructure – AI environments are provisioned automatically, eliminating manual configurations and errors,
  • Reproducibility – every infrastructure change is documented and repeatable, reducing operational risk,
  • Scalability – infrastructure can be scaled predictably without manual intervention,
  • Cost control – full control over infrastructure costs, without dependence on external API providers.

IaC for AI is not just automation - it is the foundation of predictability and control over costs and performance of AI systems.

AI that delivers real value

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:

  • Business process automation – using AI to automate repetitive tasks in applications, reducing operational costs and increasing efficiency,
  • Decision support – integrating AI into application decision processes, enabling better decisions based on data,
  • Experience personalization – using AI to personalize user experiences in applications, increasing business value,
  • Data analysis and processing – using AI to analyze large datasets in applications, delivering valuable insights,
  • Integration with existing systems – implementing AI in a way that supports existing business processes, not replacing them.

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.

How AI supports the three pillars of stable IT projects

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.

AI as a long-term investment

Building infrastructure for LLM models and using IaC requires capital investment, but it is an investment that pays off in the form of:

  • control over data and security,
  • cost predictability,
  • independence from external API providers,
  • long-term solution stability,
  • real business value delivered to applications.

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.