[GoogleIO2025] What’s new in Angular
Keynote Speakers
Devin Chasanoff functions as a Senior Developer Relations Engineer for Angular at Google, driven by web development’s creative aspects. He advocates for framework enhancements that streamline building performant applications.
Mark Thompson serves as a Developer Relations Engineer for Angular at Google, leveraging his background as an award-winning instructor to advance developer experiences. Recognized with Northwestern’s Distinguished Teaching Excellence Award in 2017, he focuses on intuitive tools and performance optimizations.
Abstract
This analytical exposition investigates Angular’s latest advancements, particularly version 20, focusing on features enhancing developer productivity and application efficiency. It dissects zoneless architectures, signal ecosystems, and server-side rendering improvements, contextualizing them within web development’s evolution. Through code illustrations and strategic insights, the narrative appraises methodologies for modular, performant apps and implications for community-driven innovation in a competitive framework landscape.
Core Features and Architectural Shifts
Devin Chasanoff and Mark Thompson herald Angular v20’s release, emphasizing developer-centric improvements. Chasanoff underscores the framework’s momentum, with features reducing pain points for scalable applications.
Zoneless operation advances to developer preview, leveraging signals’ reactivity for change detection without Zone.js. This methodology decouples rendering from DOM manipulations, implying reduced overhead in large apps.
Signals round out with forms, promising intuitive reactivity. Thompson details input/output signals for component communication, with lazy loading via deferrable views optimizing initial loads.
Code sample for deferrable view:
@defer (when isVisible) {
<large-component />
} @placeholder {
Loading...
}
Server-side rendering evolves with incremental hydration, event replay, and routing APIs, implying faster perceived loads and improved SEO.
Implications include broader adoption for high-performance sites, though require migration strategies for legacy code.
Integrations and Tooling Enhancements
Thompson highlights Firebase integrations, enabling seamless authentication and data binding. AngularFire’s signal-based APIs simplify reactive UIs.
Testing harnesses from Angular CDK facilitate component interactions, implying robust end-to-end tests.
Chrome’s performance panel tracks Angular specifics, aiding optimizations. These integrations contextualize within Google’s ecosystem, implying streamlined workflows.
Community and Future Trajectories
Chasanoff stresses community feedback shaping v20, with AI portal angular.dev/ai offering Gemini-assisted resources.
Future directions include selectorless components for incremental adoption, implying flexibility in modern stacks.
The team’s focus on experience and performance implies sustained relevance, fostering collaborative ecosystems.
Links:
[reClojure2025] LLMs + Clojure = Who needs frameworks?
Lecturer
Kapil Reddy is a software engineer known for his “business-first” approach to development. He is a prominent figure in the Clojure community, frequently contributing to discussions and ideation at the Scicloj meetups. Kapil has collaborated with other leading engineers in the ecosystem, such as Vedang Manerikar and Daniel Slutzky, to explore the intersection of artificial intelligence and functional programming. He is currently involved in developing the llms.edn project, which aims to bridge the gap between Clojure’s library-centric philosophy and the modern need for rapid project scaffolding using Large Language Models (LLMs).
Abstract
In the modern software development landscape, Large Language Models (LLMs) have significantly altered workflows, particularly in the realm of project scaffolding. However, the Clojure ecosystem, which prioritizes a philosophy of composable libraries over rigid frameworks, often presents a steep learning curve for newcomers who seek the convenience of “Rails-like” frameworks. This article explores a novel methodology introduced by Kapil Reddy that leverages LLMs to automate the composition of Clojure libraries. By utilizing a structured, native format called llms.edn, developers can describe library usage patterns in a way that LLMs can understand and execute. This approach aims to provide the convenience of a framework while maintaining the flexibility and power of Clojure’s traditional library-based architecture.
The Framework Paradox in Clojure
The debate between using frameworks versus a collection of libraries is central to Clojure’s identity. Traditional frameworks like Ruby on Rails provide a “Golden Path,” offering a set of pre-configured tools and conventions that allow for rapid prototyping. For many developers, especially those transitioning from other ecosystems, the absence of such a framework in Clojure is perceived as a significant barrier to entry. Clojure’s core philosophy leans heavily toward composition, where developers select specialized libraries—such as Ring for HTTP, Reitit for routing, and HugSQL for database access—and manually integrate them.
While this library-centric approach prevents the “black box” complexity and “magic” often associated with frameworks, it requires a deep understanding of the ecosystem. Kapil Reddy observes that LLMs are exceptionally proficient at project scaffolding, a task traditionally reserved for frameworks. The challenge, therefore, is to create a system where LLMs can assist in this scaffolding process without forcing the community to adopt a monolithic framework that would sacrifice the language’s fundamental strengths.
llms.edn: Structured Knowledge for AI Agents
To enable LLMs to effectively compose Clojure libraries, Kapil proposes a structured, Clojure-native approach to describing libraries and their common usage patterns: llms.edn. This concept is inspired by the broader llms.txt initiative but is tailored specifically for the unique requirements of the Clojure ecosystem.
The llms.edn file serves as a manifest that provides the LLM with the necessary context to understand how a library should be initialized, configured, and integrated with others. Instead of the LLM relying on potentially outdated or hallucinatory training data, llms.edn provides a source of truth directly from the library authors or the community. This structured data includes:
* Dependency declarations: Specific coordinates for tools like deps.edn or Leiningen.
* Code snippets: Standard boilerplate for starting a server or connecting to a database.
* Interoperability rules: Instructions on how a library (e.g., a router) interacts with another (e.g., a handler).
By providing these instructions in a machine-readable format, the manual task of “wiring” libraries together—often the most frustrating part for beginners—can be offloaded to an AI agent.
LLM-Powered Composition Workflows
The practical application of this methodology is an LLM-powered composition workflow. In this model, the developer describes the desired features of their application in natural language. An AI agent then queries a registry of llms.edn files to identify the best libraries for the task.
Kapil demonstrates that once the “how-to” for each library is codified, the process of generating a cohesive starter project becomes a “looper making a REST call”. This flow engineering treats the LLM as a pipeline that manages state and passes configuration data between different execution steps. This results in a “framework-like” experience where a full project structure is generated instantly, yet the underlying code remains a collection of simple, independent libraries that the developer can easily modify or replace.
The implications of this shift are profound. It suggests that the primary utility of a framework—reducing the cognitive load of setup and configuration—can now be achieved through intelligent automation. As Kapil notes, the LLM world requires more “simple software” because the models themselves introduce enough complexity; Clojure’s inherent simplicity makes it an ideal target for this kind of AI-driven orchestration.
Links:
[AWSReInventPartnerSessions2024] Inside Tripadvisor’s Real-Time Personalization with ScyllaDB and AWS (DAT204)
Lecturer
Felipe Cardeneti Mendes acts as Technical Director at ScyllaDB, guiding technical strategies for high-throughput, low-latency databases. Based in São Paulo, Felipe has extensive experience in distributed systems optimized for data-intensive applications. Dean Poulin leads data engineering at Tripadvisor, focusing on scalable solutions for personalization in travel platforms.
Abstract
This thorough assessment explores Tripadvisor’s use of ScyllaDB on AWS for real-time personalization, analyzing challenges in data-intensive apps, methodological optimizations for throughput and latency, and implications for user experience and infrastructure efficiency.
Challenges in Data-Intensive Personalization
Tripadvisor assesses user preferences rapidly to deliver relevant content, requiring systems sustaining one million operations per second with single-digit millisecond latencies. Growth escalates costs, forcing trade-offs between performance and expenses.
ScyllaDB, compatible with Cassandra and DynamoDB, offers five times higher throughput and twenty times lower latencies, reducing infrastructure spend by up to seventy-five percent.
Methodological Deployment and Performance
Migration from on-prem Cassandra to Scylla Cloud, then bring-your-own-account model, achieved zero-downtime at forty thousand operations per second. Partitioning by visitor GUID and fact type, using leveled compaction, supports read-heavy workloads.
Microservices handle over one billion daily requests with 1.2-millisecond average latency. A six-node EC2 cluster processes 340,000 operations per second at twenty-one percent CPU.
Code sample for data partitioning in ScyllaDB:
CREATE TABLE facts (
visitor_guid UUID,
fact_type TEXT,
created_at TIMESTAMP,
attributes TEXT,
PRIMARY KEY ((visitor_guid, fact_type), created_at)
) WITH CLUSTERING ORDER BY (created_at DESC);
This structure optimizes queries for user events.
In summary, ScyllaDB enhances personalization, balancing scale and cost effectively.
Links:
[DevoxxBE2025] The Future of Refactoring: Test-Driven Navigation
Lecturer
Alex Bunardzic possesses extensive tenure in software engineering, commencing with Lisp and advancing to enterprise solutions. As a Velocity Architect, he transmutes technical hurdles into commercial advantages, championing supple practices and principled development. With origins in life sciences and quantitative ecology, Alex fuses empirical principles into his endeavors, underscoring adaptable, anthropocentric setups.
Abstract
This treatise explores the fusion of artificial cognition with development routines, centering on Test-Driven Navigation (TDN) as a technique to steer AI-aided restructuring. It delves into conceptual bases from notions like boundlessness and data theory, situating them within contemporary scripting flows. Through scrutiny of approaches drawn from Extreme Programming and ecological cultivation, the narrative appraises a dynamic illustration of TDN employing AI instruments. Ramifications for transmuting creator functions from enactment-centric to tactical blueprinting are probed, underscoring prospects for realm unearthing and enduring setup progression.
Conceptual Bases: Boundlessness, Data, and Anthropic Restrictions
Anthropic intellect struggles with limitless notions, molded by adaptive adjustments to paucity and boundaries. Exemplars like Hilbert’s Inn conundrum illustrate how boundlessness defies intuition: an endlessly filled inn can house infinite newcomers by relocating occupants. This non-intuitive quality extends to quantum dynamics, where occurrences are computable yet inscrutable, as observed by physicist Richard Feynman.
In programmatic domains, data—delineated by scholar Gregory Bateson as “any disparity that effects disparity”—lacks corporeal extents, rendering it boundless. Homogeneous settings produce no data; distinctions solely transmit significance. Bateson’s treatise and Douglas Hofstadter’s opus underscore these conceptions, shaping artificial cognition views.
These bases frame AI’s function in progression. AI instills limitless prospects, opposing anthropic paucity-oriented cognition. This friction surfaces in “aura scripting” or AI-indigenous tactics, paralleling the transition from manual maneuvers to nebulous-indigenous infrastructures. Opposition mirrors prior shifts, yet anecdotal accounts—like utilizing AI for a melody rating solution—delineate pragmatic embrace. Preliminary efforts with expansive cues faltered, producing unusable script, but successive polishings triumphed, illuminating AI’s capability when appropriately steered.
Advent of AI-Indigenous Progression and Its Hurdles
AI-indigenous models advocate treating AI as a chief scripting vernacular, transcending customary syntax to dialogic mandates. This progression parallels nebulous-indigenous transitions, where mechanization supplanted manual arrangements. Nonetheless, “cue-oriented progression” frequently stumbles, culminating in “cataclysmic” deliveries—vast, ungoverned alterations that perturb setups.
Appraisals of cue crafting disclose its inadequacy; ambiguous mandates yield capricious yields, as AI deficient in innate context. Rather, structured steering is indispensable. The “triad C’s” from Extreme Programming—Card, Dialogue, Affirmation—furnish a schema: narratives as cards commence exchanges, affirmed via tangible exemplars like validations.
Ecological cultivation via succession proffers a metaphor: setups evolve progressively from desolate states to flourishing biospheres. Commencing with vanguard species that prime terrain, advancement constructs intricacy securely. In software, this equates to stepwise functionality accretion, evading sudden revisions. TDN incarnates this, employing failing validations as exact AI mandates, imposing stepwise advancement.
Technique of Test-Driven Navigation
TDN adapts the Red-Green-Refine loop for AI collaboration. Initiate with a failing validation (Red), cue AI to render it passing (Green), then polish (Refine). This curbs AI’s proclivity for expansive alterations, assuring perpetual operability.
Pivotal tenets encompass alteration validation to affirm sturdiness—modifying script to verify if validations detect regressions—and concentrating on realm precepts over rigid stipulations. Validations act as unearthing instruments, exhuming implicit precepts through successive inquiry.
Practically, TDN redirects emphasis from script purity to realm revelation. Creators furnish validations; AI enacts. This elevates functions: from artisans rectifying script to blueprinters strategizing setups. Influences like Robert Martin for pristine script, Alistair Cockburn for polygonal blueprint, and Kent Beck for Extreme Programming inform this, but AI diminishes manual restructuring necessities.
Scrutiny of Dynamic Illustration and Methods
A dynamic scripted exemplar elucidates TDN: mechanizing exterior illumination oversight predicated on time, season, and sensors. Commencing with a failing validation for illumination activation at twilight, AI fabricates minimal passing script. Successive validations append subtleties—like discerning day/night, summer/winter—prompting AI to evolve operations.
Script fragments from the exemplar:
For preliminary day/night distinction:
test('ought return daytime when hour amid 7 and 19', () => {
expect(isDaytime(12)).toBe(true);
});
AI replies with:
function isDaytime(hour) {
return hour >= 7 && hour <= 19;
}
Ensuing validations introduce seasons:
test('ought return winter for month 12', () => {
expect(getSeason(12)).toBe('winter');
});
AI fabricates segregated utilities, sustaining modularity. Alteration validation assures coverage: modifying conditionals, authenticating validation failures.
This progressivism mirrors ecological cultivation: initiating from “wasteland” (no operability), appending “forage” (basic rationale), constructing to “woodland” (sturdy realm model). Core proficiencies remain segregated from input/output, advancing verifiability.
Ramifications for Transmuting Creator Functions
TDN reconfigures progression: diminished focus on syntax, amplified on stipulation and realm archaeology. Creators emerge as commercial collaborators, unearthing precepts through validations rather than secluded enactment. This nurtures habitable setups—sturdy (firmitas), utilitarian (utilitas), aesthetic (venustas), per Vitruvius—synchronizing with user intuition via minimal surprise.
AI refines artistry, not erodes it, transitioning from infrastructural undergrowth to tactical augmentation. Setups become safeguarded, efficacious, sustainable. Challenges linger: accessing realm authorities, equilibrating ingenuity. Yet, preliminary signs intimate a maturation, situating engineers as indispensable associates.
In summation, TDN exploits AI for secure progression, transmuting restructuring into navigational revelation, pledging resilient, adaptive software biospheres.
Links:
- Lecture video: https://www.youtube.com/watch?v=tH8aqbHWgIM
- Alex Bunardzic on LinkedIn: https://ca.linkedin.com/in/alexbunardzic
- Alex Bunardzic on Twitter/X: https://twitter.com/alexbunardzic
[DevoxxUK2026] Aspiring Speakers: Learning Python to Buy Shoes
Lecturer
Isaac Oldwood is an emerging software engineer and public speaker passionate about accessible, project-based learning. His journey from mathematics student to developer exemplifies practical skill acquisition through real-world problem-solving.
Abstract
Isaac Oldwood shares a personal narrative of mastering Python by tackling an everyday challenge: automating the purchase of limited-edition sneakers. This beginner-friendly account traces the evolution from rudimentary automation scripts to sophisticated API interactions, highlighting key lessons on learning through failure, iteration, and building relevant projects.
From MATLAB to Real-World Automation: A Developer’s Origin Story
Beginning in 2016 as a first-year mathematics student at the University of Nottingham, Isaac encountered programming through a compulsory MATLAB module. Recognizing the value of coding skills for modern mathematicians, he excelled yet questioned his academic path upon receiving strong results. Seeking guidance through traditional searches, he discovered that foundational knowledge in variables and control structures should pair with building practical projects aligned with personal interests.
The chosen project involved acquiring Yeezy Boost 350 V2 “Bred” sneakers. Initial attempts employed PyAutoGUI for keyboard and mouse automation, relying on screen coordinates and arbitrary sleep timers. These approaches proved brittle against dynamic web interfaces and competitive release timings.
Subsequent iterations leveraged Selenium for browser automation, enabling direct interaction with HTML elements and conditional waits. This advancement improved reliability as scripts adapted to page changes. Further research into inter-computer communication revealed APIs, leading to direct HTTP interactions using the Requests library. By reverse-engineering checkout flows, Isaac implemented PUT requests to cart endpoints and POST requests for payment processing, dramatically reducing latency compared to full page loads burdened by images, trackers, and fonts.
Scalability challenges emerged when extending the solution to housemates. Synchronous execution created unfair queuing. Transitioning to asynchronous operations with HTTPX allowed concurrent checkouts, ensuring equitable opportunity at release moments.
Despite technical refinements, the script ultimately failed against robust anti-bot measures deployed by the retailer. Success arrived through manual effort: queuing physically outside a store at dawn. This outcome reinforced that automation serves as a learning vehicle rather than a guaranteed solution.
Conclusion
Isaac’s engaging story underscores fundamental truths about technical education. Learning proves enjoyable when rooted in passion projects. Failure constitutes an integral component of growth, yielding deeper insights than initial successes. Building tangible solutions to personal problems accelerates skill development far beyond theoretical study. Aspiring developers benefit immensely from identifying relevant challenges and iterating relentlessly toward mastery.
Links:
[VoxxedDaysBucharest2026] Mastering Performance Optimization in Java: Roberto Cortez on Writing Efficient Code
Lecturer
Roberto Cortez is a Senior Software Engineer at Red Hat and a prominent contributor to the Quarkus project, with particular expertise in configuration systems, startup performance, and runtime efficiency optimizations. With years of experience in Java development and cloud-native technologies, Roberto focuses on making Java applications faster, more resource-efficient, and better suited for modern deployment environments.
Abstract
In many development projects, functional delivery takes precedence while performance considerations are deferred until bottlenecks become apparent. Roberto Cortez challenges this approach through a detailed examination of efficient Java coding practices. Using real-world examples from Quarkus development, he demonstrates essential tools including Async Profiler for visualization, JMH for benchmarking, and Java Flight Recorder. Through iterative optimization of concrete code examples, he illustrates the importance of measurement, analysis, and continuous refinement.
The Perils of Assumption and the Imperative of Measurement
Roberto draws from his extensive work on Quarkus configuration loading to highlight how seemingly minor implementation details can have outsized performance impacts. He gently critiques the common misinterpretation of Donald Knuth’s famous quote about premature optimization, clarifying that while not every piece of code requires micro-optimization, developers must remain vigilant about critical execution paths that significantly affect user experience or resource consumption.
A central example involves a simple string prefixing operation implemented using Java Streams. While the code appears clean and idiomatic, profiling reveals substantial hidden costs in object allocations and temporary structures. This serves as a powerful reminder that intuition alone is insufficient — empirical measurement must guide optimization decisions.
Profiling with Async Profiler and Flame Graphs
Async Profiler emerges as a key tool due to its low overhead and rich visualization capabilities. When attached to a running Quarkus endpoint responsible for generating lists of names, the resulting flame graphs clearly highlight hotspots in StringBuilder usage and intermediate object creation. These visualizations prove invaluable for understanding complex runtime behavior where application code often represents only a small fraction of total execution time due to framework, JVM, and library interactions.
Roberto demonstrates practical usage patterns and interpretation techniques that enable developers to quickly identify and address performance bottlenecks.
Benchmarking with JMH for Rigorous Comparison
For precise, statistically sound measurements, Roberto turns to the Java Microbenchmark Harness (JMH). He presents detailed benchmarks comparing multiple implementations of the prefixing task: traditional Streams, parallel Streams, manual for-loops, and optimized versions reusing StringBuilder instances. Results across different Java versions (17, 21, and experimental 25) reveal how JVM improvements can render certain hand-optimizations obsolete or even counterproductive.
Additional demonstrations focus on environment variable resolution in Quarkus, where iterative refinements including custom equals and hashCode implementations yield substantial gains in both startup time and memory consumption.
Sustained Vigilance, Real-World Impact, and Lessons Learned
Performance optimization is portrayed as an ongoing discipline rather than a one-time activity. Roberto shares how optimizations introduced in Quarkus 3.5 required revisiting and partial reversion in version 3.6 due to upstream changes. The famous “One Billion Row Challenge” serves as an inspiring example of extreme creativity and technical depth in pursuit of performance.
Key takeaways include focusing optimization efforts on high-impact areas, balancing readability and maintainability concerns, and maintaining rigorous measurement practices throughout the development lifecycle. Developers are encouraged to cultivate a performance-aware mindset while avoiding premature or counterproductive optimizations.
Links:
[DevoxxFR2026] GitHub Actions as a Supply Chain Security Time Bomb: Real-World Attacks and Defensive Strategies
Lecturer
Thierry Abalea is the co-founder and CEO of Shipfox, a French AI Factory platform specializing in coding agent workflows. With a background in software development and security, he focuses on practical approaches to securing modern CI/CD pipelines in cloud-native environments.
Abstract
GitHub Actions has become a cornerstone of modern CI/CD practices, yet it remains insecure by default. Recent supply chain attacks such as those targeting tj-actions, s1ngularity, GhostAction, and Shai-Hulud have demonstrated how adversaries systematically exploit workflows to exfiltrate secrets and compromise downstream projects. This presentation dissects concrete attack vectors observed in 2025, explains why traditional mitigations fall short, and outlines actionable defenses including scoped secrets with approval workflows, minimal GITHUB_TOKEN permissions, egress controls, runner hardening, and runtime protection tools. Attendees gain a clear understanding of the current threat landscape and practical steps to secure their pipelines.
The Critical Role and Inherent Risks of CI/CD in Modern Development
Continuous integration and continuous deployment pipelines manage extraordinarily sensitive assets: source code manipulation, secret handling for production access, and package publishing. Any compromise here can lead to widespread downstream damage. Thierry Abalea emphasizes that while GitHub Actions provides powerful automation, its permissive default configuration creates a vast attack surface. Workflows often run with broad permissions, handle long-lived secrets, and interact with external networks without sufficient restrictions.
The 2025 attack wave—including Singularity targeting Nx builds, Shai-Hulud as the first npm-propagating worm, and multiple incidents against Trivy—highlighted how GitHub Actions serves as both an entry point for initial compromise and a vector for secret exfiltration and lateral movement. These incidents affected hundreds of organizations, underscoring that CI/CD security can no longer be treated as secondary to application security.
Dissecting Major Supply Chain Attacks via GitHub Actions
Several high-profile incidents illustrate common exploitation patterns. The Singularity attack combined batch injection vulnerabilities in pull request workflows with the pull_request_target trigger. This allowed attackers to exfiltrate secrets from forked repositories, including NPM tokens used to publish malicious packages. Downstream consumers of the compromised Nx tool were subsequently affected.
Shai-Hulud represented a novel worm-like propagation through npm. Attackers gained secrets via similar workflow vulnerabilities, published malicious packages, and leveraged maintainer permissions across multiple projects. This created cascading compromises as infected packages spread through dependency trees.
Trivy, a widely used open-source security scanner, suffered repeated attacks. Initial exploitation via pull_request_target and unsafe interpolation led to remote code execution, secret exfiltration (including high-privilege GITHUB_TOKENs), repository privatization, and deletion of releases. A follow-up attack succeeded due to incomplete secret rotation, enabling further malicious package publications.
These cases reveal recurring themes: overly permissive triggers, secret exposure in workflows, and insufficient isolation between CI environments and production assets.
Why Default GitHub Actions Security Falls Short
GitHub Actions operates with broad defaults that favor convenience over security. Workflows can trigger on untrusted events like pull_request_target, granting access to repository secrets. The GITHUB_TOKEN often possesses excessive permissions, especially in repositories created before 2023. Actions referenced by mutable tags (e.g., v3) can be hijacked by attackers controlling upstream repositories. Self-hosted runners, if not properly isolated, allow one compromised job to affect the entire machine.
Network egress remains largely unrestricted, enabling easy data exfiltration to attacker-controlled servers or even private repositories. Traditional advice—pinning actions and limiting secrets—proves insufficient against sophisticated chained exploits.
Practical Defenses: Hardening GitHub Actions Workflows
Effective protection requires a defense-in-depth approach. Begin by scoping secrets with approval rules, ensuring only necessary workflows can access them. Minimize GITHUB_TOKEN permissions on a per-workflow basis, adhering to the principle of least privilege. Implement egress controls to restrict outbound connections from runners.
For self-hosted runners, enforce ephemeral instances and strong isolation. Tools like Step Security provide runtime hardening and firewall-like controls around runners, while GitHub’s upcoming Level 7 runner protections promise kernel-level isolation outside the runner’s reach.
Static analysis tools such as CodeQL (free for open source) and Zizmor detect workflow vulnerabilities. Dependency review bots help manage pinned versions. Organizations should treat CI/CD as production-equivalent, applying the same scrutiny to workflows as to application code.
Runtime protections and regular secret rotation further reduce the blast radius of potential breaches. Automation of security scanning within pull requests ensures issues are caught early.
Conclusion: Treating CI/CD as Production Infrastructure
GitHub Actions represents both a productivity powerhouse and a significant supply chain risk. By understanding real attack patterns and implementing layered defenses—from minimal permissions and scoped secrets to runtime controls and automated analysis—teams can substantially reduce their exposure. Security must be integrated from the outset of workflow design rather than bolted on afterward. As attackers increasingly target the CI layer, proactive hardening becomes essential for maintaining trust in modern software delivery pipelines.
Links:
[AWSReInvent2025] Beyond Migration: Transforming Global Automotive Retail with SAP and Pan-Amazon Services
Lecturer
Sunnuk Kim is the Vice President and Head of the IT Strategy and Planning Division at Hyundai Motor Group. Based in Seoul, he is a primary architect of the group’s digital strategy, focusing on integrating legacy industrial operations with modern cloud intelligence to redefine the automotive lifecycle. Mahesh Shrivastava is a Director and Global Leader for SAP on AWS. He specializes in enterprise-scale digital transformation, helping multinational corporations move beyond infrastructure optimization to achieve true business model innovation through cloud-native ecosystems.
Abstract
The modern enterprise technology landscape is undergoing a fundamental shift where global organizations no longer view cloud migration as an isolated technical objective but rather as a catalyst for comprehensive business transformation. This article examines the strategic collaboration between Hyundai Motor Group and Amazon Web Services (AWS) to modernize its mission-critical SAP environment through the integration of “Pan-Amazon” services. By moving beyond traditional “lift-and-shift” methodologies, Hyundai has adopted a “clean core” strategy that bridges the gap between back-office ERP functions and front-end consumer touchpoints. The analysis explores how the integration of Amazon Business, Prime logistics, and multi-channel fulfillment centers with SAP allows Hyundai to optimize global sales, inventory management, and personalized retail experiences. This transformation signifies the evolution of the automotive industry into a data-driven, customer-centric retail model.
The Strategic Shift: From Infrastructure Migration to Business Evolution
Historically, large-scale enterprises approached the cloud with the narrow objective of reducing capital expenditure by transitioning physical data centers to virtualized environments. For a global manufacturer like Hyundai, the initial focus was often on the stability and performance of SAP systems that manage the “heartbeat” of production and finance. However, as market dynamics evolved toward direct-to-consumer models and digital-first interactions, the group identified that true value lay in how cloud-native capabilities could solve complex business challenges. This realization prompted a move away from simply “running” SAP in the cloud toward “transforming” the business through the cloud.
The strategic pivot was driven by an urgent need for customer-centricity, requiring Hyundai to provide seamless, omnichannel experiences that mirror the speed and predictability of modern e-commerce. Furthermore, the limitations of rigid, monolithic legacy architectures necessitated a “clean core” approach. This methodology allows the organization to maintain a stable, standard ERP foundation while rapidly innovating through extensions and external integrations. By breaking down the long-standing silos between manufacturing data and external consumer insights, Hyundai has positioned itself to make real-time decisions that directly impact global sales volume and customer retention.
Methodology: Integration of the Pan-Amazon Ecosystem
A core innovation in Hyundai’s transformation is the sophisticated utilization of “Pan-Amazon” services, a broad collection of Amazon’s diverse business units that are now integrated directly into the AWS cloud platform. This strategy extends far beyond typical compute and storage services. For instance, the integration of Amazon Business has allowed Hyundai to streamline indirect procurement and supply chain management directly within the SAP workflow, reducing manual overhead and improving spend visibility.
Furthermore, the application of Amazon Prime and its global fulfillment network to the automotive sector represents a significant methodology shift. By leveraging these world-class logistics models, Hyundai can manage automotive parts and vehicle accessories with unprecedented efficiency. This creates a “Y process” where product portfolio management and sales volume planning converge. In this model, the back-office operations managed by SAP are directly connected to the front-end retail experience. This integration ensures that when a customer interacts with a digital retail channel, the system can provide real-time data on vehicle availability, delivery timelines, and personalized configuration options, all backed by a robust, cloud-native logistics engine.
Technical Analysis of Modernized Operations
The transition from legacy environments to an AWS-integrated SAP landscape has yielded transformative results across several key performance indicators. In terms of scalability, the previous architecture was constrained by fixed capacity and physical hardware limitations, whereas the current AWS-integrated system offers elastic scaling that adapts to real-time demand spikes without manual intervention. Global inventory management has transitioned from fragmented data silos, which often suffered from latency and inaccuracies, to a unified system providing real-time visibility across all global fulfillment centers.
Customer experience has seen a similar leap in sophistication. What was once a linear and offline-heavy journey has been replaced by an integrated omnichannel digital retail platform that provides consumers with the speed and reliability they expect from modern digital platforms. This operational efficiency at scale is further supported by the ability to access the world’s largest online marketplace and fulfillment network. The technical result is a modular environment where the core ERP remains upgradable and stable while a vast array of custom, cloud-native services drive innovation on the periphery. This architecture ensures that even as the company expands into new geographic regions or business channels, the underlying infrastructure remains resilient and performant.
Implications for Global Automotive Retail and Beyond
The consequences of Hyundai’s “Go to Cloud” strategy are profound for the broader automotive sector. The industry is moving toward a state of direct-to-consumer readiness, where traditional dealership models are being augmented by digital platforms that offer complete transparency and predictability. This shift is enabled by the ability to treat vehicle sales not as a one-time transaction, but as a continuous relationship supported by digital services and efficient parts logistics.
The success of this project also highlights the importance of data-driven innovation. By analyzing vast amounts of data across the combined SAP and Amazon ecosystem, Hyundai can better forecast market trends and optimize production cycles accordingly. This represents a broader trend of Industry 4.0, where the lines between manufacturing, retail, and technology are increasingly blurred. The ability to achieve such high levels of operational agility while maintaining a secure and compliant global footprint sets a new benchmark for enterprise-scale digital transformation.
Conclusion
The collaboration between Hyundai Motor Group and AWS serves as a comprehensive blueprint for how large enterprises can successfully navigate the complexities of modernizing mission-critical systems. By prioritizing the customer experience and leveraging the full breadth of the Pan-Amazon ecosystem, Hyundai has evolved from a traditional manufacturer into a leader in digital automotive retail. The journey underscores that the future of enterprise IT is defined not just by the technology itself, but by the intelligent integration of diverse services to create tangible business value. As global competition intensifies, the move toward a “clean core” SAP environment supported by cloud-native logistics and AI will be the defining factor for sustainable growth and innovation.
Links:
[VoxxedDaysAmsterdam2026] Framework Desktop and Incus OS: An Efficient Setup for Local LLM Deployment
Lecturer
Peter Smink works with Team Roxy and collaborates with AMD on advanced hardware solutions. He focuses on practical approaches to running AI workloads locally, emphasizing privacy, cost control, and energy efficiency through modern container and virtualization technologies.
Abstract
Running large language models locally addresses critical concerns around data privacy, operational costs, and environmental impact, yet requires careful hardware and software configuration. Peter Smink presents the combination of Framework Desktop hardware with Incus OS as a compelling solution for local LLM deployment. The discussion covers the advantages of this setup, practical implementation steps, encountered challenges, and real-world performance characteristics. Through detailed examination of the installation process, GPU passthrough configuration, and model execution, the presentation demonstrates how this approach enables efficient, private, and sustainable AI development while maintaining flexibility for broader container and virtual machine workloads.
Advantages of Local LLM Deployment with Modern Hardware and Virtualization
Local execution of large language models offers distinct benefits compared to cloud-based alternatives. Privacy concerns are eliminated when sensitive data never leaves organizational infrastructure. Operational costs become predictable without recurring API charges or token-based billing. Energy consumption can be monitored and optimized at the hardware level, supporting sustainability goals. Additionally, local setups provide greater control over model selection and experimentation, unconstrained by provider limitations or network dependencies.
The Framework Desktop platform, powered by AMD Ryzen processors with integrated AI capabilities, delivers high performance within a compact and power-efficient form factor. Configurations supporting up to 128 GB of memory and efficient power envelopes ranging from 80 watts upward make it suitable for demanding workloads while maintaining reasonable energy profiles. The modular design allows for future upgrades and ensures hardware longevity beyond specific AI use cases.
Incus OS complements this hardware by providing a modern, secure, and flexible virtualization and containerization layer. Built on immutable Linux foundations with secure boot and TPM support, it offers robust isolation for workloads. The system includes built-in update mechanisms and supports both containers and virtual machines through a unified command-line interface. This versatility allows teams to run AI inference alongside other development or production services on the same infrastructure.
Implementation Process and Configuration Details
Setting up the environment begins with client preparation. The Incus client must be installed and configured with appropriate certificates for secure communication with the target system. This client serves as the primary interface for managing the remote Incus instance.
Image creation follows, utilizing the flasher tool to generate a customized Incus OS image. Configuration files specify critical parameters including the target disk, graphics drivers for AMD hardware, and PCI passthrough settings for GPU access. The process ensures that the resulting image includes necessary drivers and security configurations tailored to the Framework Desktop hardware.
On the hardware side, BIOS preparation involves enabling secure boot and clearing existing certificates to accommodate the new installation. CPU and memory settings are optimized for the installation phase. Once the USB image is created and booted, the automated installation process configures the system according to the provided specifications.
Post-installation steps focus on network configuration and virtual machine setup. A dedicated network is established for VM connectivity. The AI server virtual machine is then created with substantial memory allocation and direct GPU passthrough. This configuration enables the virtual machine to leverage hardware acceleration for model inference.
Within the virtual machine, environment preparation includes kernel updates, installation of necessary tools, and configuration of user groups for GPU access. The latest AMD graphics drivers ensure optimal performance. Verification steps confirm that the GPU is properly recognized and accessible to the inference software.
Operational Characteristics and Performance Considerations
The resulting setup demonstrates strong performance for local inference tasks. Token generation rates vary based on model size and configuration, with observed averages ranging from 25 to 60 tokens per second and peaks approaching 90 tokens per second under optimal conditions. Power consumption remains efficient, typically between 18 and 130 watts depending on workload intensity.
The combination supports models that may exceed the capacity of individual graphics cards by leveraging system memory and CPU resources effectively. Privacy is maintained as all processing occurs locally without external data transmission. Cost predictability eliminates concerns about variable cloud pricing or usage spikes.
The platform’s reusability adds significant value. Should AI-specific requirements evolve, the hardware remains fully functional as a general-purpose server or development workstation. This contrasts with specialized AI accelerators that may become obsolete or underutilized outside narrow use cases.
Challenges and Lessons Learned
Several practical challenges emerge during implementation. Certificate and client configuration require precise sequencing to ensure secure connectivity. Incorrect order or missing privileges can result in systems that fail to communicate properly. GPU passthrough configuration demands careful attention to hardware and driver compatibility.
Kernel updates and driver installations must align with the specific hardware platform. Recent changes in driver APIs have occasionally created compatibility hurdles, though newer versions have improved stability significantly. Memory and storage requirements for both the host system and virtual machines necessitate careful planning to avoid resource contention.
Despite these considerations, the overall setup process proves manageable with appropriate documentation and systematic verification at each stage. The modular nature of both hardware and software components allows for iterative refinement as requirements evolve.
Strategic Value for AI Development and Beyond
This hardware and software combination addresses multiple strategic objectives simultaneously. Privacy-conscious organizations gain a viable alternative to cloud services without sacrificing performance. Development teams benefit from rapid iteration cycles and direct hardware access for experimentation. Cost-sensitive projects maintain predictable operational expenses while avoiding vendor lock-in.
The solution extends beyond pure AI inference. The underlying Incus platform supports diverse workloads, making the infrastructure adaptable to changing organizational needs. Teams can experiment with different models, quantization techniques, and inference engines while maintaining consistent operational procedures.
Energy efficiency aligns with growing sustainability requirements in technology operations. The ability to monitor and control power consumption at the hardware level supports both environmental goals and operational cost management.
As AI adoption continues across industries, solutions that balance capability, control, and efficiency become increasingly valuable. The Framework Desktop paired with Incus OS represents one practical approach to achieving these objectives while maintaining flexibility for future requirements.
Links:
[DevoxxGR2026] GenAI on Kubernetes: Training, Inference, and Serving in Production Environments
Lecturer
Alessandro Vozza is a seasoned cloud-native advocate and technologist with deep expertise in Kubernetes and AI/ML operations. He contributes actively to open-source communities and focuses on practical, scalable deployments of generative AI workloads. As a speaker and practitioner, Alessandro emphasizes operational excellence, resource efficiency, and the integration of modern AI tools within established cloud-native platforms.
Abstract
In this hands-on tutorial at Devoxx Greece 2026, Alessandro Vozza guides developers through the complete lifecycle of running generative AI workloads on Kubernetes. From distributed training jobs with GPU scheduling to optimized inference and scalable model serving, the session demonstrates how to leverage operators, autoscaling, vector stores, and frameworks like KServe, Ray, vLLM, and Kubeflow. Attendees gain actionable insights into designing efficient GPU clusters, fine-tuning models securely, and deploying production-grade architectures that integrate seamlessly with existing Kubernetes expertise.
The Convergence of Kubernetes and Generative AI
Kubernetes has evolved into the de facto platform for orchestrating complex, resource-intensive workloads, including those powered by generative AI. Vozza begins by contextualizing the challenges: training large models demands massive parallel computation across GPUs, inference requires low-latency serving under variable traffic, and the entire pipeline must remain observable, secure, and cost-effective. Traditional approaches struggle with these demands, but Kubernetes patterns—scheduling, autoscaling, and declarative resource management—provide a robust foundation.
The session highlights how the community has responded with specialized tools. Projects like Kubeflow address the full ML lifecycle, while KServe and vLLM focus on high-performance inference. These build upon core Kubernetes capabilities, allowing teams to treat AI workloads with the same rigor applied to microservices.
Distributed Training and GPU Orchestration
Training generative models is computationally intensive and benefits enormously from Kubernetes’ scheduling strengths. Vozza demonstrates launching distributed training jobs, emphasizing GPU-aware scheduling through device plugins and resource requests. Nodes are labeled with GPU capacity, enabling the scheduler to place pods on suitable hardware.
The tutorial covers hyperparameter tuning with tools like Katib, which automates experimentation across multiple configurations. Fine-tuning involves augmenting base models with domain-specific data, a process that Kubernetes orchestrates reliably through persistent volumes and checkpointing. Attendees learn to monitor training progress using built-in observability and handle failures gracefully with retries and job controllers.
Resource efficiency emerges as a key theme. Techniques such as multi-instance GPU (MIG) partitioning allow a single physical GPU to support multiple smaller workloads, maximizing utilization without over-provisioning expensive hardware.
Inference Serving and Model Deployment
Once trained, models must be served efficiently. Vozza walks through deploying inference endpoints with KServe, which abstracts the complexities of scaling and routing. vLLM serves as the high-throughput inference engine, leveraging continuous batching and paged attention for superior performance.
The architecture supports multi-model serving, where a single deployment handles various models based on request characteristics. Gateway API extensions make the ingress layer LLM-aware, enabling intelligent routing based on factors like key-value cache state or model specialization. This ensures optimal resource allocation and minimal latency.
Autoscaling plays a critical role. Horizontal Pod Autoscaler (HPA) combined with KEDA reacts to custom metrics such as queue depth or tokens processed per second, dynamically adjusting replicas to match demand while controlling costs.
Operational Considerations and Best Practices
Production readiness demands comprehensive observability. Vozza integrates Prometheus exporters and logging to track token throughput, latency, and GPU utilization. Security best practices include least-privilege access for model endpoints and encrypted communication.
The tutorial addresses common pitfalls: managing model registries for versioning, handling cold starts through caching, and ensuring reproducibility across environments. By treating models as first-class Kubernetes citizens, teams achieve consistent deployments from development to production.
Practical Roadmap and Future Directions
Participants receive a working reference setup they can adapt immediately. Vozza encourages starting small—perhaps with a single-model inference service—before scaling to distributed training and multi-model architectures. The session reinforces that Kubernetes knowledge directly transfers to AI operations, lowering the barrier for traditional platform teams.
Looking ahead, evolving features like dynamic resource allocation and improved GPU topology awareness will further streamline GenAI workloads. The message is clear: Kubernetes is not merely compatible with generative AI; it is becoming the preferred operational layer for the entire lifecycle.