Velocity Resource Center

The True Cost of a High-Severity Production Incident?

Companies today operate in a high-stakes environment where downtime costs extend well beyond lost revenue. You should be aware of the multi-layered impact of a single high-severity incident and how a proactive approach can protect your company’s bottom line, brand reputation, and team morale.

5 Ways to Improve Developer Experience

Investing in developer experience not only cultivates a team of happy engineers, but it encourages innovation, improves agility, and increases development velocity. If you are looking to improve DX at your organization, here are five places to start.

Build a Real-Time Analytics Service in Python with Neon and Kafka

Build a Real-Time Analytics Service in Python with Neon and Kafka

Optimizing Dockerfiles for Dev and Deployment

Cache Data in Redis with Golang

Learn how to leverage the in-memory data store, Redis, with applications written in Golang to cache data and optimize the performance of your microservice-based application in this post.

Kubernetes Persistent Volumes for Beginners

Get started with Persistent Volumes in Kubernetes with this video.

Kubernetes Pods for Beginners

Learn the basics of Kubernetes Pods in this video.

Minikube for Local Kubernetes Development

Get started with a local Minikube cluster in this video.

Kubernetes ReplicaSets and Deployments for Beginners

Learn the basics of Kubernetes ReplicaSets and Deployments in this video.

Kubernetes Containers for Beginners

Learn the basics of images and containers for Kubernetes in this video.

Getting Started with Argo Workflows

Argo Workflows is a K8s native workflow engine that allows you to run all kinds of workflows in Kubernetes by leveraging native resources, such as K8s Pods, to execute the individual steps of the workflow. Workflows can be kicked off in all kinds of ways, which – along with the enormous range of customizations possible – is what makes Argo Workflows such a versatile tool for running cloud-native workflows.

Build a Microservice-based App in Golang with Gin, Redis and MongoDB and Deploy it in K8s

Golang is arguably the best choice of language for writing cloud native applications. In this post we quickly cover Golang’s strengths, and then create a sample blog application that combines synchronous and asynchronous networking for distinct workflows within the app.

Goroutines, Channels and WaitGroups in Golang

Goroutines provide a means for multiprocessing in a Golang application, allowing multiple processes to run simultaneously. In addition, Channels and WaitGroups enable passing data between threads or blocking one thread until another completes. In this post, we explore examples of each.

Build an Event-Driven Architecture with FastAPI and Redis Pub/Sub & Deploy it in Kubernetes

Request-response based networking in microservice architectures can result in unwanted latency in your cloud native application. Learn the basics of event-driven architectures built with Redis as a way to increase your application’s processing speed in this post.

Getting Started with K8s Init Containers

Kubernetes init containers provide a means of configuring an environment in K8s for an application to run that doesn’t require changing the application’s source code. In this post, we discuss how init containers work, when you would use one, and show an example in a sample app.

Passing Secrets: Using Vault with Kubernetes

Use Vault to store secrets as an alternative to less secure options like committing the secrets directly into version control or hard-coding a secret in a config file that is passed to an application at startup.

Goodbye Logs, Hello Traces: Part 3 - Show me the money

This is the third and final part in a multi-part series on using OpenTelemetry and distributed tracing to level up your system observability.

Passing Secrets in Kubernetes: Techniques for Accessing Secrets

In this post, we discuss two options to consume secrets: directly from the secrets manager (via code in the app), or as a configuration provided by the infrastructure (via configuration file/environment variables).

Goodbye Logs, Hello Traces: Part 2 - See it in the wild

This is part two in a multi-part series on using OpenTelemetry and distributed tracing to level up your system observability.

Build an Async DB Worker with MongoDB, Redis and Python and Deploy it in Kubernetes

Often, in order to keep an application responsive at scale, you’ll need to pass long-running jobs to another process that can handle them asynchronously in the background. In this post, we’ll look at a simple way to achieve this with Python, Redis and Redis Queue.

How To Create and Manage Multi-Tenant Cluster Solutions Using Self-Service

As part of the LF Live series, Velocity recently teamed up with the Linux Foundation to host a webinar about different methods and tools to build and manage multi-tenant Kubernetes clusters. Watch the recording here.

Goodbye Logs, Hello Traces: Part 1 - A proper introduction

This is the first post in a multi-part series on using OpenTelemetry and distributed tracing to level up your system observability.