Nele Lea Uhlemann
Developer Advocate at Fiberplane
Actions
Nele Uhlemann is a Developer Advocate at Fiberplane. Her passion is enabling collaboration among multiple stakeholders that are involved in building and running Software. Switching sides from application development to infrastructure topics she understands the challenges to enable knowledge sharing to run systems more efficiently.
Building Smarter Serverless APIs with TypeScript and Vector Search
Building a modern API requires consideration of various components and services. Developers often spend more time selecting tools and configuring infrastructure than focusing on the core business logic of the API. This talk explores building a serverless JSON API using TypeScript and the HONC stack—a powerful combination of Hono, Drizzle, Neon, and Cloudflare Workers. By leveraging these tools, developers can concentrate on business logic achieving efficient, scalable, and maintainable serverless applications.
Additionally, the talk highlights the integration of vector search—an approach to data retrieval that is relevant for applications involving recommendations, natural language processing, and multimedia search. By combining the HONC stack with Weaviate, a vector search database, the talk outlines how to effectively leverage vector search using Weaviate's TypeScript libraries, enabling developers to build smarter, more intuitive APIs with minimal overhead.
Chaos Unleashed Workshop: Embrace The Chaos In Real-Time!
Get ready for a hands-on chaos engineering workshop that takes interactive learning to the next level! Picture yourself immersed in a chaotic environment, guided by a captivating narrative, and empowered to shape both the chaos and its resolution.
G and Nele will kick off with a ChaosToolkit-driven simulation of pod and network failures in a production Kubernetes environment. Attendees, using a voting app, will collaboratively troubleshoot the system, exploring insights through examining logs, metrics, traces, and terminal outputs. Essential tools, such as Prometheus, alongside visualization in Perse, will play a key role in the workshop.
Recognizing that humans are integral to such scenarios, dice rolling will introduce some unplanned humanistic chaos.
This workshop combines the excitement of a live-action game with the principles of chaos engineering, delivering a unique and unforgettable experience. Join the open chaos and find out if we can escape from it in 90 minutes.
Chaos Unleashed: Embracing Chaos Engineering For Kubernetes Resilience
In this session, we'll delve into the thrilling tale of a passionate new engineer who unwittingly throws a wrench into a Kubernetes-based production environment. Through the session, you'll discover how chaos engineering can be a game-changer in identifying and tackling vulnerabilities within intricate cloud-native ecosystems.
In the presentation, we use ChaosToolkit to test system redundancy by deleting some pods and by introducing network failures. Logs, metrics, and traces through OpenTelemetry allow for analysis. We delve into tools like Prometheus and Perse but also tackle the question: what is the minimum amount of telemetry data that we need to understand our system quickly and recover from failure?
Failures are unavoidable and chaos engineering prepares teams to handle them more effectively. Join a session of planned chaos and see how it fosters a better understanding of Kubernetes system components and observability tooling while promoting collaboration and communication.
Combining Progressive Delivery and Observability for More Secure Deployments
When looking at deployments, we have pre-deployment strategies to mitigate the risk of breaking things, like tests and progressive delivery. Regarding the post-deployment phase, we are not as strong with methods and techniques as in the pre-deployment phase.
Progressive delivery already touches the post-deployment phase. But there are some more measurements we can consider to create a post-deployment strategy. Dashboards with metrics logs and traces are one-way but not stateful. The presentation will present a concept using Argo Rollouts for progressive delivery and leverage Argo CD notifications after a deployment to collect telemetry data with OpenTelemetry and Prometheus statefully. It presents a concept around function-level metrics based on the codebase that helps collaborate better with the application engineers if things go wrong after a deployment. In the post-deployment phase, we can’t mitigate the risk of breaking things, but we can reduce the effort of solving them.
Fixing Potholes And Broken Roads: Devs Can Troubleshoot the Network With Ops Too!
“Oops! It’s the Network!”
No developer, operator, or engineer wants to hear this, but here we are! When the network presents a challenge it requires them to comb through a variety of systems and tools to find the culprit. This is challenging when operating at scale in heterogeneous platforms and environments. Also, when developers test or build something locally or in a cloud environment, connectivity challenges can be a barrier to progress. Maybe a developer is trying to address latency with tracing capabilities but needs a quick lesson on how to use a tracing tool. Perhaps a platform team needs a quick refresher on networking tools to quickly identify problem areas.
In this tutorial, Nele and Marino demonstrate how to discern and troubleshoot application issues across a few scenarios. We’ll use and describe several tools that operate at different OSI layers, how they pinpoint issues, and how they enable developers and operators to be more self-service oriented with network issues.
From Small Gatherings to Thriving Communities: Unleashing the Power of Meetups
Open Source without a community is like apple crumble without apples. It might work, but it is not the same. Community is a catalyst for developing open-source tooling. There are different ways we can engage with our community, and creating a Meetup program is one of them. Nele and Andrea have been involved with Meetups of all stages for most of their careers and are here to share their experience to bring your community from zero to success.
The challenges of running a Meetup program can be very different depending on the group's location, size, and age. In the talk, we will share our perspectives on how to create brand-new Meetup groups and what is needed if you run a well-established one while keeping everyone engaged. Let’s talk about the crumbles that groups in different stages need and how we can make sure to add the apples to our recipes too.
Thinking with Process Models: How Businesses Can Leverage Process Model Notation for Agile Software
A common thread uniting businesses and their engineering teams is agility. Requirements for software come from business departments, and are then implemented by developers. Getting a minimum viable product (MVP) out the door means having the ability to iterate quickly on ideas and processes, and doing so in a way that is collaborative and consumable across teams.
This is where implementing Business Process Model and Notation (BPMN) can be a lifesaver. BPMN 2.0 provides a graphical language that breaks down complex topics with clear visual diagrams for business executives and cross-functional team members, and is executable in a variety of languages for developers. Removing the effort it takes to translate text or model-based requirements into code and vice versa makes agile software development possible. This session will highlight how BPMN enables businesses to succeed at scale, and supports alignment between business and IT departments in an organization.
Thinking with Process Models: Wie man Prozessmodellierung für die agile Softwareentwicklund nutzt
Ein gemeinsamer Nenner, der Unternehmen und ihre Entwicklungsteams verbindet, ist Agilität. Die Anforderungen an die Software kommen aus den Geschäftsabteilungen und werden dann von den Entwicklern umgesetzt. Um ein Minimum Viable Product (MVP) auf den Markt zu bringen, muss man in der Lage sein, Ideen und Prozesse schnell zu iterieren, und zwar auf eine Art und Weise, die teamübergreifend kollaborativ und verwendbar ist.
An dieser Stelle kann die Implementierung von Business Process Model and Notation (BPMN) eine große Hilfe sein. BPMN 2.0 bietet eine grafische Sprache, die komplexe Themen mit klaren visuellen Diagrammen für Führungskräfte und funktionsübergreifende Teammitglieder aufschlüsselt und für Entwickler in einer Vielzahl von Sprachen ausführbar ist. Der Wegfall des Aufwands, text- oder modellbasierte Anforderungen in Code zu übersetzen und umgekehrt, ermöglicht eine agile Softwareentwicklung. In dieser Sitzung wird aufgezeigt, wie BPMN den Erfolg von Unternehmen in großem Maßstab ermöglicht und die Abstimmung zwischen Geschäfts- und IT-Abteilungen in einem Unternehmen unterstützt.
Tracing A Path From PlatformOps To Devs: Two Sides To The Observability Coin
As applications move quickly through development cycles we often overlook observability for rapid troubleshooting and bug fixes. Ops teams have similar challenges when platforms don’t provide enough observability context. The pragmatic view is that all systems and applications must have tooling to provide and analyze telemetry data. How can Dev and Ops teams capture adequate samples of telemetry data for deep analysis?
Are metrics enough or can we benefit from tracing data using it to debug issues?
Where should observability be instrumented: in code, in infrastructure, or both?
How can we leverage observability micro-frameworks alongside Zipkin, Jaeger & Kiali to assist with performance debugging?
This session deeply defines a variety of metrics to solidify how applications behave while picking up patterns to add scale and resilience. The speakers will explain telemetry and tracing and demonstrate this functionality at the application code level and within K8s using a service mesh.
Workflowengines the glitter glue for microservice orchestration
Breaking down a monolith or managing transactions in a distributed system are common challenges today when we talk about IT architecture. Still, we need to be able to find the right glue for a polyglot system.
The glue should not be too sticky, ensuring everything remains loosely coupled. Still, we want to be able to understand more complex Sagas in our system. Modern workflow engines provide a glue to orchestrate microservices in a loosely coupled way. Like adding glitter to glue the right workflow engine adds functionalities to define Saga rollbacks, error handling, and retries and therefore helps to reduce boilerplate code.
The presentation will give insight on how to orchestrate microservices with Open Source technology.
Multitenant Mystery – Every Byte Has a Secret
Every byte has a secret. To uncover the truth, you'll dive into the mysterious world of multitenancy, one of the pillars of modern SaaS solutions. The plot thickens as a precious guitar goes missing from a residential building housing only rockers. Join Nele and Thomas on a detective mission to unravel what happened.
While investigating, you’ll learn the secrets of OpenTelemetry and explore hands-on examples of defining an observability strategy for your cloud-native applications, including how to:
- Instrument your code with OpenTelemetry;
- Manage logs, metrics, and traces via a unified API;
- Collect telemetry data using the newly graduated OTLP protocol.
However, getting visibility into multi-tenant applications requires more. You’ll discover how to add more context to the telemetry data based on the tenants, understand the difference between high-cardinality and low-cardinality values, and learn troubleshooting techniques.
Put on your detective hat and help solve the mystery.
Multitenant Mystery: OpenTelemetry, Tour de France and the Stolen Bike
Every byte has a secret. To uncover the truth, you'll dive into the mysterious world of multitenancy, one of the pillars of modern SaaS solutions. The plot thickens as a bike goes missing from the hotel hosting the cyclists racing in the Tour de France. Join Nele and Thomas on a detective mission to unravel what happened.
This hands-on session illustrates what observability looks like when troubleshooting a complex cloud-native system in action. As you investigate, you'll discover the secrets of OpenTelemetry and learn how to:
- Instrument your code with OpenTelemetry;
- Manage logs, metrics, and traces via a unified API;
- Collect telemetry data using the OTLP protocol.
However, getting visibility into multi-tenant applications requires more. You’ll discover how to add more context to the telemetry data based on the tenants. By the end, you’ll better understand why you should prioritize observability during development.
Put on your detective hat and help solve the mystery.
Modern Workflow engines: Orchestration of Services, Humans, and Robots
In this workshop, you will learn how modern workflow engines orchestrate polyglot microservices and reduce boilerplate code. We’ll focus on cloud-native applications and distributed architectures. Attendees will develop an application using the Camunda 8 workflow engine. Along the way, they will learn Open standards including BPMN for defining your processes and learn how to automate them.
The main focus will be on Service Orchestration, but we’ll also manage to outline how to orchestrate human tasks and how to combine them in order to map processes end-to-end.
But that's not all! Attendees will also get the chance to orchestrate RPA bots using the Open Source python library Robot framework. The goal is to demonstrate how you can include otherwise unreachable UI components into the process.
Everyone will leave running a process with services, user tasks, and RPA bots. Join our 2 hours journey of orchestration fun (Coding knowledge is handy but no specific language is required)
Build Your Stream Processing Apps Dead Easy Without Dying on the Complexity of Infrastructure
Streaming data represents a constant flow of events. One example might be a newer-generation car. Every time the location of the car changes, a new event is created. It’s called "streaming data" because there are thousands of these events resulting in a constant stream of data. Such data should be processed incrementally using stream processing techniques and technologies that allow you to handle the high throughput.
In this session, we will show you how to implement such a use-case with Java and developer productivity in mind using a modern application platform on Kubernetes and a workflow engine to maintain state and handle errors in event-driven microservice architectures.
We will leverage the capabilities of the VMware Tanzu Application Platform based on famous OSS projects like Knative and Camunda’s workflow engine Zeebe to be able to focus on the implementation of the actual business logic with the Spring ecosystem.
Be proactive about state in a reactive system
There are multiple things to consider when creating reactive systems. Orchestration with reactive APIs is not easy and often error-prone. Introducing a message broker to handle and manage asynchronous communication is common practice in reactive systems and leads to message-driven architectures. In such architectures, it becomes harder to manage and monitor the state of your systems. Having transparency about the state is essential, especially considering more complex principles, for example, the Saga Pattern. This talk introduces ways how to manage the state in a reactive system. It outlines the concept of modern workflow engines and ways to integrate them into your Java environment with message brokers or use them in a standalone fashion.
Architecting Observability Capabilities for Your Internal Platform With OpenTelemetry
Your organization is building an internal platform to enable product teams to deliver value faster, safer, and better. Developers need visibility into their workloads running in production. It’s time to add observability capabilities to the platform and support the new requirement.
How can you streamline the management of various telemetry data like logs, metrics, and traces? How can you offer observability as a service to developers without vendor lock-in?
Nele and Thomas will demonstrate a solution based on OpenTelemetry, covering the main architectural patterns and features with real-world examples.
- Collecting telemetry data via unified interfaces and standard protocols.
- Integrating existing functionality managing metrics with Prometheus/OpenMetrics.
- Decoupling APIs and back-end storage to enable moving seamlessly between different options, such as from Jaeger to Tempo.
- Including application auto-instrumentation as part of the golden paths offered to developers.
Architecting Observability Capabilities for Your Internal Platform With OpenTelemetry
Your organization is building an internal platform to enable product teams to deliver value faster, safer, and better. Developers need visibility into their workloads running in production. It’s time to add observability capabilities to the platform and support the new requirement.
How can you streamline the management of various telemetry data like logs, metrics, and traces? How can you offer observability as a service to developers without vendor lock-in?
Nele and Thomas will demonstrate a solution based on OpenTelemetry, covering the main architectural patterns and features with real-world examples.
- Collecting telemetry data via unified interfaces and standard protocols.
- Integrating existing functionality managing metrics with Prometheus/OpenMetrics.
- Decoupling APIs and back-end storage to enable moving seamlessly between different options, such as from Jaeger to Tempo.
- Including application auto-instrumentation as part of the golden paths offered to developers.
50 shades of process automation
I work for a company that produces an Open Source Software that automates processes —any type of process. Is that scary? Not at all.
Come and join my presentation to learn about the different layers and shades of process automation. The talk highlights the main aspects, from human task management to microservice orchestration (including some robots (RPA)). It outlines what can go wrong and how it can be fixed by adding more transparency to the development.
KubeCon + CloudNativeCon Europe 2024 Sessionize Event
CNCF-hosted Co-located Events Europe 2024 Sessionize Event
API World 2023 Sessionize Event
WeAreDevelopers World Congress 2023 Sessionize Event
WTF is SRE? A Conference by SREs for SREs 2023 Sessionize Event
Techorama 2022 BE Sessionize Event
WTF is Cloud Native Sessionize Event
Festival Agile Trends Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top