Web & App Technologies.

HTML5 (HyperText Markup Language, version 5) is the foundation of every website and web application. HTML defines the semantic structure of web content: headings, paragraphs, lists, links, forms, media, and more. The browser interprets this structure and renders it for the user.

HTML5 introduced native support for audio, video, canvas, and SVG — without external plugins. Newly introduced semantic elements such as <header>, <nav>, <main>, <article>, and <footer> significantly improve accessibility and SEO, because search engines and screen readers understand the page structure better.

vona builds all websites with clean, semantic HTML5 — accessible (WCAG), fast, and machine-readable for search engines and AI crawlers.

CSS3 (Cascading Style Sheets, version 3) controls the visual appearance of web pages: layout, typography, colors, spacing, animations, and responsive behavior. CSS3 fundamentally modernized web design with features such as Flexbox, CSS Grid, custom properties (variables), animations, and transitions.

CSS custom properties enable design systems with reusable tokens — vona uses them for consistent color, type, and spacing scales across all pages. clamp() and viewport-relative units create fluid typography without breakpoint spaghetti.

Modern CSS significantly reduces the dependence on JavaScript for visual effects: scroll animations, hover states, dark/light mode switching — all purely declarative and performant in the browser.

Bootstrap is one of the most widely used CSS frameworks in the world — developed by Twitter and maintained today as an open-source project. It provides a comprehensive 12-column grid system, prebuilt UI components (navigation, modals, forms, cards), and a consistent visual system.

Bootstrap enables rapid development of responsive interfaces without having to write CSS from scratch. Bootstrap 5 removed the jQuery dependency and introduced CSS custom properties, improved utilities, and a reworked flexbox grid (CSS Grid optional).

vona uses Bootstrap selectively in projects that require fast implementation or a familiar component system — and falls back on custom CSS solutions when performance, individual design systems, or a distinctive aesthetic are called for.

JavaScript is the only programming language that runs natively in the browser — making it the indispensable foundation for interactive web applications. From simple form validation to complex single-page applications, from DOM manipulation to AI integrations in the browser: JavaScript makes it all possible.

With ES6+ (arrow functions, promises, async/await, modules, destructuring), JavaScript has become a modern, readable language. Node.js brought JavaScript to the server as well — today JavaScript runs in the browser, on the server, in databases (MongoDB), and on microcontrollers.

vona relies on vanilla JavaScript for performance-critical applications (canvas animations, scroll effects) and uses frameworks such as Vue.js or React for more complex UI requirements — always with an eye on bundle size and load time.

TypeScript is an extension of JavaScript developed by Microsoft that adds static typing to the language. TypeScript code is compiled to JavaScript and runs anywhere JavaScript runs — but the development process benefits from type checking, autocompletion, and early error detection.

Especially in larger projects and teams, TypeScript significantly reduces the error rate: type errors are caught at compile time instead of at runtime. Interfaces, enums, generics, and strict types make code self-documenting and safe to refactor.

TypeScript is now the standard for professional frontend development: Next.js, Angular, NestJS, and many other frameworks are built on TypeScript. vona uses TypeScript for more complex applications and APIs.

jQuery was for years the most widely used JavaScript library in the world and democratized web development: cross-browser-compatible DOM manipulation, AJAX requests, and event handling with an elegant, consistent API — at a time when browsers differed greatly.

With modern browser standardization and ES6+, many jQuery features are available in vanilla JS. Nevertheless, jQuery remains relevant in certain projects: it is in use on millions of existing websites, integrates seamlessly into existing systems, and reduces boilerplate for simple DOM tasks.

vona uses jQuery selectively for projects where it is already in place or where fast, simple DOM interactions without framework overhead are called for.

Three.js is the leading JavaScript library for 3D graphics in the browser — an abstraction layer over the complex WebGL API that enables hardware-accelerated 3D rendering without proprietary plugins. With Three.js, 3D scenes, animations, interactive objects, and special effects can be built directly in the browser.

Use cases range from interactive product configurators and 3D renderings to data-driven visualizations and immersive web experiences. Three.js integrates with the browser DOM and responds to user input — mouse movements, touch, and VR controllers.

vona uses Three.js for demanding visual web applications where 2D is not enough: interactive data visualizations, 3D product viewers, or experimental brand experiences.

PHP (Hypertext Preprocessor) is a server-side scripting language that has shaped the web to a great extent. Around three quarters of all websites with a known server-side language run on PHP — including WordPress, Wikipedia, and Facebook (in its early years). PHP runs on the server, processes requests, and generates dynamic HTML before it is sent to the browser.

Modern PHP versions (8.0 and later) have professionalized the language with JIT compilation, union types, named arguments, fibers, and many other features. Frameworks such as Laravel and Symfony bring structured, testable architecture to PHP projects.

vona uses PHP for classic web backends, WordPress development, API backends, and middleware solutions — particularly for projects where PHP infrastructure is already in place or where shared hosting without container support is required.

Python is the dominant language in AI and data science — and at the same time one of the most versatile programming languages there is. Its clear, readable syntax and huge ecosystem of libraries make Python the first choice for machine learning, data analysis, automation, and backend development.

In the AI context, Python is indispensable: PyTorch, TensorFlow, Hugging Face Transformers, LangChain, LlamaIndex — all leading AI frameworks are Python-native. For integrating LLMs into business processes, RAG pipelines, or fine-tuning workflows, Python is the standard.

vona uses Python for AI integrations, data processing pipelines, automation scripts, and backend services — wherever Python's AI ecosystem is to be put to use.

Vue.js is a progressive JavaScript framework for building user interfaces — created by Evan You (formerly of Google) and today entirely community-driven. Vue is considered the most approachable of the three major frontend frameworks (React, Angular, Vue): a gentle learning curve, excellent documentation, and an elegant template syntax.

Vue 3 with the Composition API brought better code organization, TypeScript integration, and improved performance. Nuxt.js (the Vue equivalent of Next.js) adds server-side rendering, static site generation, and file-based routing to Vue.

vona uses Vue.js for interactive single-page applications, dashboard interfaces, and complex form systems — especially when an approachable framework is called for in projects with mixed teams.

React is the JavaScript library developed by Meta (Facebook) for building component-based user interfaces. React fundamentally changed frontend development: the declarative, component-based approach with a virtual DOM and unidirectional data flow is the industry standard today.

With Next.js (Server Components, App Router), React has reclaimed the server side: code runs on the server, in the browser, or on the edge, as needed. React Hooks enable reusable, stateful logic in functional components — without classes.

The React ecosystem is the largest in the frontend space: from state management (Zustand, Redux, Jotai) to UI libraries (shadcn/ui, Radix) to testing tools. vona uses React for complex web applications that benefit from a mature ecosystem.

Node.js is a JavaScript runtime built on Google's V8 engine — it takes JavaScript out of the browser and onto the server. The non-blocking, event-driven I/O approach makes Node.js particularly efficient for I/O-intensive applications: APIs, real-time systems, streaming, and microservices.

npm (Node Package Manager) is the world's largest software registry with several million packages — and thus the foundation of the modern JavaScript ecosystem. Express.js, Fastify, and NestJS are popular frameworks for Node.js APIs and servers.

For vona, Node.js is the basis for build tools, local development servers, and backend services — particularly when JavaScript know-how is carried over from the frontend to the backend context and a single language across the entire stack is called for.

Angular is Google's complete frontend framework — not a library, but an opinionated full framework with everything enterprise applications need: dependency injection, routing, forms, HTTP client, testing, and CLI. Angular is TypeScript-native and enforces structured architecture.

The advantage of the "batteries included" approach: teams make fewer architectural decisions, and code is more consistent and more predictable. Angular Signals (from v16) bring a reactive programming model that can work without Zone.js for better performance and simpler development.

vona uses Angular for large enterprise applications where a complete framework with clear structure, long-term support, and support for a large team is called for.

Tailwind CSS is a utility-first CSS framework — instead of prebuilt components, Tailwind provides atomic utility classes (flex, pt-4, text-gray-700) from which designs are composed directly in the HTML. This approach eliminates switching between HTML and CSS files and speeds up development considerably.

Tailwind v4 brought CSS-native configuration, performance improvements, and a more compact syntax. shadcn/ui — the most popular React component library — is based on Tailwind and has significantly strengthened the ecosystem.

vona uses Tailwind for projects where fast iteration and a consistent design token system are called for — particularly in combination with React/Next.js or Vue. For custom designs with complex animation requirements, we fall back on plain CSS.

Electron makes it possible to build native desktop applications with web technologies — HTML, CSS, and JavaScript. Electron combines Chromium (for the UI) with Node.js (for system access) in a single app. Well-known Electron applications: VS Code, Slack, Discord, and GitHub Desktop.

The decisive advantage: web developers can build desktop apps without learning native languages (Swift, Kotlin, C++). One codebase runs on macOS, Windows, and Linux. Auto-updates, system notifications, file system access — Electron gives web apps access to native OS features.

vona builds desktop applications with Electron for clients who need a cross-platform desktop solution without setting up separate native development teams for each operating system.

Ionic is a framework for building hybrid mobile apps with web technologies. Ionic apps run in a native WebView and offer native UI components and gestures for iOS and Android — built once, deployed on both platforms and as a progressive web app.

Ionic integrates with Angular, React, and Vue and combines them with Capacitor (the modern successor to Cordova) for access to native device features: camera, GPS, push notifications, biometrics, and more. Capacitor also allows the use of native Swift/Kotlin plugins.

vona uses Ionic for mobile app projects where a single codebase for iOS, Android, and the web is called for and the team already brings web development know-how.

Firebase is Google's backend-as-a-service platform — a complete backend infrastructure for web and mobile apps without running your own servers. Firebase covers most backend requirements: Firestore (NoSQL database with real-time sync), Authentication, Cloud Functions, Hosting, Storage, and more.

Firestore's real-time feature is particularly powerful: data synchronizes automatically between all connected clients — ideal for chat applications, live dashboards, and collaborative tools. Firebase Authentication offers ready-to-use social login (Google, Apple, GitHub) in minutes.

vona uses Firebase for projects where fast time-to-market matters and no dedicated backend team is available — MVPs, prototypes, and growing consumer apps.

Flutter is Google's UI framework for cross-platform development — with a single codebase for iOS, Android, web, Windows, macOS, and Linux. Flutter uses the Dart programming language and renders all UI elements itself via Skia/Impeller — instead of wrapping native components.

The result: pixel-perfect consistency across all platforms and excellent performance thanks to direct rendering without bridges to native components. Hot reload provides instant feedback during development. Flutter's widget system is exceptionally composable.

vona uses Flutter for ambitious mobile and desktop projects where high performance, a native-like look and feel, and a single codebase across all platforms are called for.

Swift is Apple's modern programming language for building native iOS, macOS, watchOS, and tvOS applications. Introduced in 2014 as the successor to Objective-C, Swift combines expressive syntax, type safety, and modern language features with the performance of compiled code.

Swift Concurrency (async/await, actors) brings structured, safe concurrent programming. SwiftUI — Apple's declarative UI framework — makes it possible to build interfaces for all Apple platforms from a shared codebase with live previews in Xcode.

For projects that need deep integration with the Apple ecosystem, maximum performance, and native App Store access, Swift is the first choice. vona builds native iOS apps with Swift and SwiftUI.

Xcode is Apple's official development environment (IDE) for all Apple platforms — iOS, macOS, watchOS, and tvOS. Xcode integrates the code editor, Interface Builder, debugger, profiler (Instruments), simulator, and the direct App Store deployment workflow in a single application.

Especially valuable: the iOS Simulator makes it possible to test apps on various device configurations without physical hardware. Instruments offers in-depth performance profiling for CPU, memory, GPU, and energy. Xcode Cloud integrates CI/CD directly into Apple's infrastructure.

All native Apple development — whether Swift or Objective-C — is inseparably tied to Xcode. vona uses Xcode for the development, testing, and signing/distribution of iOS applications.

Android Studio is Google's official development environment (IDE) for Android, built on JetBrains' IntelliJ IDEA. Code editor, layout editor, debugger, profiler, emulator and the Gradle build system come together in one application — for Kotlin, Java and modern interfaces with Jetpack Compose.

Especially valuable: the Android Emulator tests apps on different devices, screen sizes and Android versions without needing a physical device for every variant. The Profiler shows CPU, memory, network and energy use, and Compose previews give quick feedback while designing.

Anyone developing for Android ends up in Android Studio — even with cross-platform frameworks such as Flutter, build, emulator and signing run through it. vona uses Android Studio for development, testing and preparing releases for the Google Play Store.

Unity3D is one of the world's most widely used real-time development platforms for 2D and 3D applications — from mobile games to desktop and console applications to AR/VR experiences. Unity's component-based architecture (GameObjects & Components) and visual editor enable fast iteration and short development cycles.

Unity supports more than 20 target platforms from a single codebase — iOS, Android, WebGL, Windows, macOS, PlayStation, Xbox, and many more. C# as the scripting language offers a familiar, type-safe environment. The Asset Store ecosystem provides ready-made assets, plugins, and tools that significantly shorten development time.

vona uses Unity for interactive experiences, visualizations, and gamification projects — wherever classic web or app development reaches its limits and immersive, high-performance 2D/3D rendering is called for.

Laravel is the leading PHP framework — elegant, expressive, and with a complete ecosystem that covers the most complex web applications. Laravel follows the MVC pattern (Model-View-Controller) and comes with Eloquent ORM, Blade templates, Artisan CLI, queues, events, notifications, and much more out of the box.

Laravel Livewire enables reactive interfaces without a JavaScript framework — PHP classes drive dynamic UI components. Inertia.js connects Laravel seamlessly with React or Vue for modern SPAs with server-side routing. Laravel Forge and Vapor simplify deployment and scaling.

vona uses Laravel for demanding PHP backends, APIs, content platforms, and business applications — wherever PHP is the foundation and an elegant, maintainable architecture is called for.

CakePHP is a proven PHP framework that follows the principle of "convention over configuration": through uniform naming conventions for database tables, models, and controllers, CakePHP automatically generates many boilerplate tasks — less configuration, more productivity.

CakePHP scores with a built-in ORM, a robust security system (CSRF protection, SQL injection prevention, XSS filters), and an efficient caching system. The Bake CLI generates controllers, models, and views from existing database structures.

vona maintains and extends existing CakePHP applications — a framework that runs in well-maintained production systems at many mid-sized companies and offers a solid foundation for PHP code maintained over the long term.

Symfony is one of the most powerful and flexible PHP frameworks — and at the same time a library of reusable components on which Laravel, Drupal, Magento, and many other projects are built. Symfony is the framework of choice for complex enterprise applications with high demands on structure and scalability.

The dependency injection container, event dispatcher, Twig template engine, Doctrine ORM integration, and the Messenger queue system are core components that make Symfony a complete platform. Symfony's long-term support (LTS) versions offer multi-year support.

vona develops and maintains complex Symfony applications — particularly for projects with complex domain models, high security requirements, or existing Symfony infrastructure.

Yii (Yes It Is) is a high-performance PHP framework with a focus on performance and developer productivity. Yii stands out for fast code scaffolding via Gii (the built-in code generator), a powerful Active Record ORM, flexible RBAC authorization, and a solid caching system.

Yii 2 is stable and production-proven — many business applications have been running reliably on Yii for years. The framework is particularly strong for database-intensive applications with complex data models and administration interfaces.

vona develops and maintains Yii-based systems — with a focus on the stability of existing applications, modernization of legacy code, and targeted extensions without rewriting the entire application.

Zend Framework — continued today as Laminas — is Zend's enterprise PHP framework, which for years formed the backbone of large business applications. Laminas is the continuation of Zend Framework under the Linux Foundation and is still maintained.

Laminas follows a component model: individual Laminas packages can be used independently — from HTTP abstraction to authentication to internationalization. The MVC framework is complete but optional. Many legacy systems in the enterprise space run on Zend/Laminas.

vona maintains and modernizes Zend- and Laminas-based applications — an important field, since many mid-sized companies run business-critical systems on this foundation that need to be maintained and developed further step by step.

MySQL is one of the world's most widely used open-source relational database systems. MySQL stores structured data in tables and enables flexible queries via SQL (Structured Query Language) — from simple SELECT queries to complex joins across multiple tables.

MySQL is the standard in LAMP environments (Linux, Apache, MySQL, PHP) and runs behind millions of websites, WordPress installations, and web applications. InnoDB as the default storage engine offers ACID transactions, foreign key constraints, and row-level locking.

vona regularly uses MySQL as a backend database alongside PostgreSQL and MariaDB — in combination with PHP backends, Laravel, or directly via Docker-based development environments.

MariaDB is a fork of MySQL developed by the MySQL community — created after Oracle's acquisition of MySQL to secure a truly open-source path. MariaDB is largely API- and SQL-compatible with MySQL, but offers its own optimizations, new storage engines, and features that MySQL does not have.

Aria (a crash-safe MyISAM replacement), ColumnStore (for analytics), Spider (for sharding), and improved JSON support are MariaDB-specific features. In many Linux distributions (Debian, Ubuntu), MariaDB is the default replacement for MySQL.

vona uses MariaDB where MySQL compatibility is desired but a fully open-source stack without commercial Oracle dependencies is required — and uses it as the backend database in various production AI projects.

PostgreSQL ("Postgres" for short) is regarded as one of the most advanced open-source database systems and is a popular alternative to MySQL in the developer community. Postgres supports full SQL compliance, complex queries, JSON data, full-text search, CTEs, window functions, and is highly extensible through extensions.

Especially in the AI context, Postgres has become highly relevant thanks to pgvector: the extension enables the storage of and efficient search in vector data — the foundation for RAG systems and semantic search without a separate vector database. Supabase (a Postgres-based Firebase equivalent) has popularized PostgreSQL as a BaaS platform.

vona often uses PostgreSQL as a backend database and recommends it for projects with complex data models, high integrity requirements, or the need for vector storage for AI applications.

Apache HTTP Server is one of the longest-running and most widely used web servers in the world — in active development since 1995 and to this day the backbone of countless web hosting infrastructures. Apache is the "A" in LAMP (Linux, Apache, MySQL, PHP) and comes preinstalled at practically every shared hosting provider.

Apache's .htaccess system enables directory-specific configuration without a server restart — ideal for URL rewriting (mod_rewrite), redirects, and access controls. Virtual hosts make it possible to host multiple domains on one server. The module system is highly extensible.

vona uses Apache in shared hosting environments and for PHP-based web projects that make use of .htaccess configuration and the hosting providers' widespread Apache infrastructure.

NGINX (pronounced "Engine X") is a high-performance web server, reverse proxy, and load balancer — originally developed to solve the C10K problem (10,000 simultaneous connections). In modern production and cloud environments, NGINX is now often the first choice.

NGINX's asynchronous, event-driven architecture scales particularly well under heavy load: thousands of simultaneous connections with minimal memory consumption. As a reverse proxy, NGINX sits in front of Node.js, Python, or PHP-FPM backends and handles TLS termination, caching, compression, and load balancing.

In vona's Docker-based production environments, NGINX is the standard for routing incoming requests to container services — easy to configure, highly stable, and excellently documented.

Docker is the leading platform for containerization — a technology that packages applications and all their dependencies into portable, isolated containers. With Docker, "It works on my machine" is a thing of the past: the container runs identically on the developer's laptop, in staging, and in production.

Docker Compose defines multi-service applications declaratively: database, backend, frontend, cache — all services, their connections, and volumes in a single docker-compose.yml. Docker Hub is the largest registry for public container images.

Docker is an integral part of vona's development and deployment workflow: standardized local development environments, reproducible builds, and the basis for Kubernetes deployments in larger infrastructures.