Vasil Kosturski

How Smartsheet built a remote MCP server on AWS

Fri, 17 Jul 2026 00:00:00 GMT

As enterprise teams adopt AI agents, those agents need structured access to the data inside systems like Smartsheet. How Smartsheet built a remote Model Context Protocol server on AWS to give AI clients that access.

Generation Got Cheap, Trust Didn’t: A Multi-Agent Trading System with Guardrails and Traceability

Tue, 23 Jun 2026 19:31:50 GMT

Generation got cheap, trust didn’t. How a 4-trader multi-agent system uses output guardrails and per-run audit trails to close the verification gap.

Distributed Tracing Demo with OpenTelemetry and Grafana Cloud

Sun, 06 Jul 2025 18:52:47 GMT

Discover how to set up end-to-end distributed tracing in a microservices architecture using OpenTelemetry and Grafana Cloud. This hands-on guide walks you through instrumenting Java and Go services, visualizing traces, and gaining deep insights into your system’s behavior.

Monitoring Kafka in Kubernetes with Prometheus and Grafana

Fri, 24 Jan 2025 09:46:18 GMT

This article illustrates monitoring Kafka on Kubernetes using Prometheus and Grafana. We’ll deploy Kafka and Zookeeper, add Kafka Exporter, configure Prometheus to scrape metrics, and set up Grafana dashboards for visualization.

Leader Election and Failover with Zookeeper – Case Study

Sun, 20 Oct 2024 14:29:52 GMT

Learn how to implement leader election and failover using Zookeeper, .NET Core, and Docker. This article demonstrates building a distributed system with automatic leader election, handling failures gracefully to ensure high availability and fault tolerance.

Unit and Integration Testing in Apache Flink

Sun, 04 Aug 2024 10:29:47 GMT

This article provides a practical guideline for unit and integration testing in Apache Flink. Using a financial fraud detection application as an example, we demonstrate how to write effective tests to ensure the correctness of your Flink jobs.

AWS Data Lake: Handling News Data Stream via Firehose C# Client, Athena, Glue, and MySQL RDS

Fri, 16 Feb 2024 08:51:13 GMT

This guide walks you through building a sample Data Lake in AWS by pushing a News API data stream into S3 using a Firehose C# client, analyzing the data with Athena, and setting up an ETL process via Glue to load the data into MySQL RDS.

[Guest Post] Breaking Barriers: How Technology Fuels Career Success for Individuals with Disabilities

Fri, 26 Jan 2024 07:52:12 GMT

In today’s technology-driven world, opportunities for career advancement are increasingly accessible to individuals with disabilities. The advent of new technologies has opened doors that were previously closed, offering innovative ways to overcome traditional barriers. From job search platforms to accessible software, technology is a game-changer in leveling the playing field for those with disabilities. In this article, courtesy of VKonTech.com, you’ll discover how leveraging these technologies can significantly enhance career prospects for people with disabilities.

AWS Site-to-Site VPN with strongSwan

Sun, 19 Nov 2023 12:19:59 GMT

This blog post offers a detailed tutorial on configuring strongSwan for an AWS Site-to-Site VPN. It includes step-by-step instructions, security practices, and troubleshooting tips for robust connectivity between local networks and AWS.

AWS RDS Replication and Recoverability

Wed, 20 Sep 2023 08:20:15 GMT

In this demo, we set up primary and replica MySQL RDS instances in two regions. We then insert some data into the primary and read from the replica, accessing the databases through EC2 hosts. We also configure a CloudWatch alarm for high replication lag and demonstrate promoting the replica.

The Outbox Pattern with Mongo, Kafka and Debezium in C#

Tue, 27 Jun 2023 07:43:54 GMT

Discover a practical solution for the Dual Write Problem in distributed systems using the Outbox Pattern. This guide presents a C# demo app with MongoDB, Kafka, and Debezium, illustrating reliable data propagation between services.

Kafka Messaging with Cloud Events, Protobuf, and Polymorphic Types

Tue, 09 May 2023 08:43:18 GMT

This article explores producing and consuming Kafka messages in Protobuf format, adhering to Cloud Events spec, and covers polymorphic data type serialization.

Kafka Messaging with Protobuf and Schema Registry in C#

Wed, 12 Apr 2023 08:49:53 GMT

In this article, we explore Kafka with Protobuf & C#, including a demo for message production & consumption. See how to manage your schema using Confluent Schema Registry and Control Center.

Producing and Consuming Kafka Messages in CloudEvents Format Using the C# SDK

Thu, 16 Mar 2023 08:08:46 GMT

A blog post about using C# to produce and consume Kafka messages in CloudEvents format. We’ll use JSON for serialization for now, but I’ll also explore Avro and Protobuf in a subsequent article.

Exploring Kafka Streams Partitioning, Scaling, and Fault Tolerance

Thu, 23 Feb 2023 08:25:11 GMT

Exploring Kafka Steams Partitioning, Scaling, and Fault Tolerance – we’ll build a simple streaming app and inspect the contents of the repartition topic, RocksDB state store, and the Kafka internal changelog topic. Also, we’ll see how the workload gets distributed between the running app instances.

Integration Tests for your Kafka Producer with “Testcontainers” in C#

Thu, 08 Dec 2022 09:14:03 GMT

An article about integration tests for your Kafka workflow. Using C# and the “Testcontainers” framework, we first run Kafka in Docker, call an API that will push a message to Kafka, consume the produced Kafka message ensuring it’s correct, and finally drop the created containers.

Kafka Networking via Wireshark

Thu, 10 Nov 2022 08:36:43 GMT

A blog post where we use Wireshark to trace the Kafka networking protocol. The client is a simple C# app interacting with a multi-broker Kafka cluster.

Exploring Kafka Listeners in Docker

Sun, 09 Oct 2022 09:28:57 GMT

In this article, I’ll introduce Kafka listeners, the client-broker “handshake” and pub/sub interactions.

Running Containerized .NET Scheduled Tasks with AWS Fargate – Part 2

Mon, 15 Aug 2022 09:27:19 GMT

In this article, we’ll continue where we left off and see how to properly handle the networking issues we had last time. Concretely, we need to find a way to host our Fargate Task in a private subnet (so it’s not reachable publicly) but also allow for outbound internet traffic through a static public IP address. We will whitelist this IP in Atlas, making the Mongo cluster accessible from the running container.

Running Containerized .NET Scheduled Tasks with AWS Fargate – Part 1

Sun, 31 Jul 2022 12:27:15 GMT

In this couple of articles, I’ll demonstrate how you can deploy a sample .NET console app to AWS and run it periodically as a Fargate task. That’s a common use case for any kind of background service you need to run on some predefined time intervals.

Sentiment Analysis of Stocktwits Messages using LSTM in PyTorch

Mon, 11 Jul 2022 08:32:36 GMT

In this article, I’ll present a demo project for classifying the sentiment of posts from the Stocktwits social media. The community on Stocktwits is full of investors, traders, and entrepreneurs. Each message posted is called a Twit. This is similar to Twitter’s version of a post, called a Tweet. Using Pytorch, we’ll build a model around these twits that generate a sentiment score.

GraphQL, Node, Apollo and React (Social Media Demo Project) – Part 2

Thu, 09 Jun 2022 07:21:39 GMT

In this article, I’ll present the UI part of the Social Media demo project we started exploring last time. In the previous post, you dug into the GraphQL API and how to send queries via the Apollo Playground. Now it’s time to bring it all together and see how the React front-end integrates with the API using Apollo Client.

GraphQL, Node, Apollo and React (Social Media Demo Project) – Part 1

Wed, 25 May 2022 09:05:09 GMT

It can’t go unnoticed that GraphQL is being adopted by plenty of reputable companies like Facebook, Shopify, Twitter, and many more. For quite some time, I hadn’t had the chance to explore it and understand what it brings to the table. Still, probably like many of you, I’ve read some isolated references here and there, gaining intuition about what kind of API design pain points GraphQL is meant to solve. So I decided to spend some time learning GraphQL, its pros and cons, and get a better feeling of the scenarios when it can improve the general quality of a system and integration workflows.

Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI – Part 3

Fri, 29 Apr 2022 09:43:47 GMT

Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI, Part 3 – a demo project part of the Udacity “Cloud Developer” Nanodegree. In this post, you will see how to deploy the sample system to Kubernetes using AWS EKS.

Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI – Part 2

Fri, 01 Apr 2022 09:44:35 GMT

Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI, Part 2 – a demo project part of the Udacity “Cloud Developer” Nanodegree. In this post, you will see how to set up Continuous Integration with Travis CI.

Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI – Part 1

Wed, 23 Mar 2022 09:23:32 GMT

Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI, Part 1 – a demo project part of the Udacity “Cloud Developer” Nanodegree.

Deploying Your Node API to AWS Using Elastic Beanstalk (Demo Project)

Sat, 05 Mar 2022 10:38:35 GMT

Deploying your Node API to AWS using Elastic Beanstalk – a demo project part of the Udacity “Cloud Developer” Nanodegree.

Monitoring Public Transportation with the Kafka Ecosystem (Demo Project)

Mon, 14 Feb 2022 10:14:14 GMT

Monitoring Public Transportation with the Kafka Ecosystem – a demo project part of the Udacity “Data Streaming” Nanodegree. It contains data streaming workflows using Kafka Producers and Consumers, JSON and Avro serialization, Kafka Connect (JDBC), REST Proxy, Robinhood Faust, and KSQL.

Should You Migrate Your Reporting Queries From a “General Purpose” DB (MongoDB) to a Data Warehouse (ClickHouse)? (Performance Overview)

Fri, 21 Jan 2022 09:53:29 GMT

Migrating Your Reporting Queries From a “General Purpose” DB to a Data Warehouse – Performance Overview. The article focuses on MongoDB and ClickHouse, but most takeaways apply to other “traditional” DBs and “data warehouse” solutions.

Causal Consistency Guarantees in MongoDB – Lamport Clock, Cluster Time, Operation Time, and Causally Consistent Sessions

Mon, 13 Dec 2021 08:02:50 GMT

Exploring Causal Consistency in MongoDB – the article goes through the concepts of Lamport (Logical) Clocks, Operation Time, Cluster Time, and Causally Consistent Sessions that lead to solving the “Read Your Write” consistency violation.

Causal Consistency Guarantees in MongoDB – “majority” Read and Write Concerns

Mon, 22 Nov 2021 18:10:06 GMT

A code example of how to break the Read You Write consistency in Mongo. Followed by a review of “majority” reads and writes. This will move the discussion towards Causally Consistent Sessions that I’ll cover next.

Causal Consistency Guarantees – Case Studies

Thu, 04 Nov 2021 16:18:30 GMT

When is Eventual Consistency not sufficient in a Distributed System? This article explores Causal Consistency Guarantees and describes the most popular ones – Read Your Write, Monotonic Reads, Monotonic Writes, Writes Follow Reads.

MongoDB Change Data Capture via Debezium Kafka Connector with a .NET 5 Client

Wed, 29 Sep 2021 16:35:59 GMT

MongoDB Change Data Capture via Debezium Kafka Connector with a .NET 5 Client

TensorFlow Serving gRPC Endpoint in Docker with a .NET 5 Client

Mon, 06 Sep 2021 09:29:53 GMT

Tensorflow Serving gRPC Endpoint in Docker with a .NET 5 Client

Predicting English Premier Leagues Games Using Transfermarkt Market Values

Thu, 12 Aug 2021 17:41:52 GMT

Predicting English Premier League games based on Transfermarkt market values for the home and away team. It’s fascinating how close we can get to the bookies’ prediction with such a simple model. This proves the impact money has on the game of Football (Soccer).

Predicting Football Clubs Winning Percentage in the English Premier League Using Pythagorean Expectation

Tue, 20 Jul 2021 17:28:05 GMT

Pythagorean Expectation for the English Premier League

Making Predictions in C# with a Pre-Trained TensorFlow Model via ONNX

Sun, 27 Jun 2021 16:53:09 GMT

Making Predictions in C# with a Pre-Trained TensorFlow Model via ONNX.

Exploring the async/await State Machine – Stack Traces and Refactoring Pitfalls

Wed, 09 Jun 2021 17:58:30 GMT

Call stacks in async methods are fundamentally different compared to synchronous execution. This leads to pitfalls where seemingly reasonable refactoring can make a method “disappear” from the Stack Trace. Let’s see why and how.

Course Review – “Deep Learning Specialization” by Andrew Ng, DeepLearning.AI on Coursera

Wed, 26 May 2021 17:39:20 GMT

If you have some beginner knowledge in Machine Learning and want to dive into Deep Learning with its’ modern applications in Computer Vision and NLP – taking the “Deep Learning Specialization” by Andrew Ng on Coursera is a great way to achieve that. Here is a full review of the Specialization.

Course Review – “Machine Learning” by Andrew Ng, Stanford on Coursera

Thu, 13 May 2021 16:27:00 GMT

The Machine Learning course by Andrew NG at Coursera is one of the best sources for stepping into Machine Learning. It has built quite a reputation for itself due to the authors’ teaching skills and the quality of the content. Admittedly, it also has a few drawbacks. Here’s a complete course review:

The Experienced Developer Stepping Into Machine Learning – Why and How?

Thu, 29 Apr 2021 16:06:32 GMT

An article on stepping into Machine Learning as an experienced Developer. How to overcome self-doubt, Imposter Syndrome and get the right mindset. You’ll also see some great online courses to start with!

Exploring the async/await State Machine – Nested Async Calls and ConfigureAwait(false)

Thu, 25 Mar 2021 16:06:28 GMT

An article on the internals of nested async/await calls. You’ll see a very detailed workflow diagram with all the execution steps. This also helps to understand precisely why and when we need to use ConfigureAwait(false) in our libraries.

Exploring the async/await State Machine – Synchronization Context

Mon, 01 Mar 2021 15:29:30 GMT

The Synchronization Context is an abstraction that lets you run a piece of code asynchronously without thinking about the specifics of the current environment. How does it work, and when is it invoked as part of the async workflow? Let’s explore those topics!

Exploring the async/await State Machine – Series Overview

Sun, 07 Feb 2021 09:02:23 GMT

I wrote a series of articles describing the async/await State Machine produced by the C# compiler when it encounters an asynchronous method. The discussion starts with a high-level conceptual overview and gradually moves towards the intriguing technical details and performance optimizations.

Exploring the async/await State Machine – Concrete Implementation

Thu, 21 Jan 2021 15:20:15 GMT

Let’s examine the concrete implementation of the async/await State Machine along with all the intriguing optimizations performed by the compiler.

Exploring the async/await State Machine – Conceptual Implementation

Mon, 28 Dec 2020 18:44:12 GMT

A conceptual implementation of the async/await State Machine

Exploring the async/await State Machine – Main Workflow and State Transitions

Sat, 12 Dec 2020 10:26:22 GMT

The async/await State Machine can be easily understood with a comprehensive workflow diagram that models the program flow and the state transitions. Such a higher-level representation is a mandatory step before diving into the implementation details. Let’s see how that looks!

Exploring the async/await State Machine – The Awaitable Pattern

Sat, 21 Nov 2020 09:54:36 GMT

The Awaitable Pattern plays a vital role in the whole async/await workflow behind the scenes. The best way to understand how it works is to build your own awaitable type. Let’s see how!

The Intuitive Guide to Understanding Closures in C#

Sun, 25 Oct 2020 13:45:07 GMT

How are closures implemented in C#? How do they “capture” environment variables from different scopes? The idea is simple, but it can have complex implications. That’s why it’s essential to understand the concept in detail. Let’s get some practical intuition inspecting the IL code as a source of truth.

Polymorphism on Steroids – Dive Into Multiple Dispatch (Multimethods)

Fri, 02 Oct 2020 13:14:20 GMT

The common understanding of Polymorphism takes into account only the runtime type of the “receiving” object. That’s the implementation in most languages. But what if we also consider the method arguments as part of the runtime method resolution logic? That’s the idea behind “Multiple Dispatch.”

The “Clash of Styles” Series – FP vs. OOP as a Daily Choice

Mon, 31 Aug 2020 13:19:26 GMT

The “Clash of Styles” series compare OOP and FP from a very practical standpoint. Modern general-purpose languages support both of the paradigms. Being conscious of that and choosing the right style for your use case is vital for ending up with an elegant and maintainable system.

Clash of Styles, Part #6 – FP in OOP via the Visitor Pattern

Wed, 19 Aug 2020 14:05:34 GMT

The Visitor Pattern addresses a fundamental limitation of Object-Oriented modeling. In OOP, adding a new “operation” is tricky. You have to modify the existing classes, which is error-prone and violates OCP. Let’s look beyond the standard UML diagram and see how the Visitor solves this problem.

Clash of Styles, Part #5 – Double Dispatch, or When to Abandon OOP

Wed, 22 Jul 2020 13:14:33 GMT

OOP is established to the point that we sometimes follow absurdly complicated “idiomatic” patterns(tricks). One example is the Double Dispatch technique, which is a quite puzzling chain of polymorphic calls. Let’s see it in action and compare it to a quite elegant Functional alternative.

Clash of Styles, Part #4 – Adding Support for Rational Numbers with FP

Thu, 02 Jul 2020 13:23:37 GMT

FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles series.

Clash of Styles, Part #3 – Extensibility via OOP and FP

Wed, 17 Jun 2020 12:33:15 GMT

The choice between FP and OOP can directly affect the maintainability characteristics of your program. What is “easy” to add in OOP is “hard” in FP and vice versa. How can that be presented in terms of the Open-Closed Principle? What are some practical examples? Explore those topics in Part #3 of the Clash of Styles series.

Clash of Styles, Part #2 – Operations Matrix via FP

Sat, 30 May 2020 09:20:56 GMT

How do we “interpret” our requirements with a Functional Programming mindset? How does it encourage us to decompose our program in terms of Operations? How is that precisely the opposite of the OOP perspective? Learn about it in the second part of the “Clash of Styles” series. Examples in C# and F#

Clash of Styles, Part #1 – Operations Matrix via OOP

Fri, 15 May 2020 13:11:44 GMT

OOP or FP? C# or F#? Is it just a matter of style? These series will give you a lot of food for thought. Enjoy Part #1

Course Review – “Programming Languages” Series on Coursera

Wed, 29 Apr 2020 17:22:54 GMT

“Programming Languages” Series on Coursera is IMO, one of the best classes on foundational programming language paradigms. I strongly recommend it. You’ll be writing your own mini interpreter in Racket. Here is a full course review. Do you have your own favorite online class?

Don’t Help Your Clients to Deadlock

Tue, 21 Apr 2020 14:51:54 GMT

If you’re not careful what and when you invoke from within a critical section, you may cause a deadlock. Everything may seem correct from yours’ and your clients’ perspective, but out of a sudden, the program may go to sleep forever. In this article, I’ll demonstrate some scenarios when this can happen and what you can do(or even should do) to mitigate the risk. But first, let’s do a quick refresher on the lock statement in C# and why we use it. The easiest way to read and write to some shared data from multiple threads and make sure it doesn’t get corrupted is to use some kind of a lock. There are various types of locks in .NET Framework like Monitor, SpinLock, ReaderWriterLockSlim. The most straightforward construct is the lock statement(which is just a simple wrapper around the Monitor), and we can safely say it works well in the majority of the cases. All the examples in this article will be based on it. But the conclusions would be valid for the other types of locks as well. Please note this article is not about strategies and patterns for parallel programming. In many cases, you may avoid locking altogether,…

The Dispose Pattern Step by Step

Wed, 01 Apr 2020 18:51:39 GMT

How to avoid memory leaks? When is the Garbage Collector not going to help you? How to make sure you implement IDisposable exactly right for your use case without falling into the “overdesign trap?” Explore those topics with a lot of practical examples.

A Practical Intro to Covariance and Contravariance in C#

Tue, 17 Mar 2020 19:39:22 GMT

When defining a generic interface, have you received a hint from Resharper like “The type parameter T could be declared as covariant” (or “contravariant”)? If so, have you then blindly applied the proposed refactoring which decorates your generic parameter with the in or out keyword? Like so: I know I’ve done this a few times before deciding to dig deeper into what these terms actually mean and how they affect my type’s behavior. Type variance is one of the topics developers work with pretty much on a daily basis but don’t always understand it well. I will discuss what it exactly means for a type to be covariant, contravariant or invariant, how are those terms represented via the in and out keywords, the semantics of the so called input and output positions, and how all of this can make our types more flexible and useful. When I was researching the topic myself, I’ve come across some resources online that get a little bit theoretical and academic. That’s probably because the terms covariance and contravariance have their deep mathematical origin. This is not something I will bother you with here. In this blog post, I’ll try to develop the practical intuition…

FirstOrDefault() is a Code Smell

Fri, 28 Feb 2020 15:10:48 GMT

FirstOrDefault() is one of the most (over)used IEnumerable extensions. Of course, it has its’ valid use cases not only semantically but sometimes from a performance perspective. In many cases, though, you can utilize alternative methods to convey your intentions more cleanly.

Avoid Conversion Operators

Fri, 14 Feb 2020 11:40:14 GMT

Prefer constructor overloads or factory methods over implicit or explicit conversion operators.

GetHashCode() Pitfalls

Fri, 07 Feb 2020 14:07:55 GMT

GetHashCode() is one of the functions you should probably avoid implementing yourself. It generates a lot of confusion among developers and can lead to some hard to track bugs when implemented poorly. The goal of this article is to help you understand the common mistakes developers make when implementing GetHashCode() and some general misconceptions when it comes to computing hash codes for your custom types in C#. Note that this is not a hash function design and implementation guideline. Rather, the main focus will be on GetHashCode() in .Net and more specifically: The difference between GetHashCode() behavior for reference and value types. Implementation details you need to be aware of when defining your own GetHashCode() version. Hash Codes for Reference and Value Types Every object in C# has a default behavior for generating an integer value called a hash code. This is the value that a hash-based container like HashSet or Dictionary uses to store and retrieve objects. The objects are grouped together by their hash codes into buckets or slots. Multiple objects can produce the same hash key. This is what’s called a hash collision. To store an object in a hash container, its hash code is computed, which…