Chris Dielschnieder
SOFTWARE DEVELOPER
PROJECT HISTORY
Aveva PI API to Esri Integrator Desktop App
Kvale Consulting | Project Dates: Jan 2026 - Oct 2026
TL;DR It builds background worker processes running on timed intervals, fetches data from a source API, and sends it to a target API.
This was a project started from scratch, and I wasn't given much detail. Just a few rough project parameters, and a few suggestions about what would be nice to have. I set to researching and brainstorming until I could put down some project requirements before writing any code.
- Functional Requirements: Create a design document outlining requirements
- Architecture: Decide on monolithic vs client/server
- Tech Stack: Choose languages and frameworks
- Database: Create ERD diagrams for database tables for a then-unknown database type - MsSQL was the eventual choice
- Deployment and Production: Consider how the production environment will work
Functional Requirements
-
Primary task #1 - Fetch PI web API JSON data on timed intervals
- Show the user all available JSON assets and make them fetchable.
- Allow the user to select the data they want and save the choices as run settings.
- Activate the run settings on timed intervals. Run the intervals as background tasks.
-
Primary task #2 - Shape the JSON payload and send to target
- Allow user to choose from list of targets where to send the payload.
- Clean, flatten, and process PI API data to match shape of chosen target. Send the payload.
Architecture
The decision was then to choose between two main designs:
- Monolithic: Bundle all processing and operations together in a single unit using C#
- Client/server: Create separate back and front ends using web development technologies
We chose #2. Why? Plain HTML/CSS is the way to go for complex UI work.
Tech Stack
Finally the fun part! Deciding which languages and frameworks to use.
Choosing the client/server design meant we were building a web app disguised as a desktop app - let's keep it all in TypeScript.
-
Electron: C++ binary wrapper allowing us to run our frontend web
code natively
- Runs a Chromium browser instance that steers the web development code into C++
-
Fastify: NodeJS Express-like framework used to build our backend
REST API
- Known for speed, which was important since the app is very background-task heavy
- Built-in APIs like decorators and plugins keep things simple and efficient by default
-
Vue.js: JS frameworks offer the best developer experience for
building UI
- Advertised as the fastest of the virtual-dom frameworks, and works well with Electron
-
Prisma: Modern ORM handles database interaction
- If we needed to support different databases we didn't want to re-write our own SQL for each one
- Prisma ORM supports all the major databases
- PrimeVue: Vue UI component design suite
Deployment and Production
Previous design decisions are related to the application's deployment procedure – it's deployed to a client's personal server isolated behind a firewall or proxy, making it inaccessible from the open internet.
In this single tenancy model each installation needs to provide the entire processing and database apparatus needed for all app operations. Every deployment is a separate isolated instance.
Shipping the frontend Electron side is pretty standard. The challenge is the Fastify backend. It ships as an executable wrapped by some C# making it runnable as a Windows service. The client must bring their own MsSQL database.
DIY Dynamometer
Lytehorse | Project Dates: May 2022 - Aug 2022
TL;DR Dynamometers are used to test vehicles. They start at around $25,000. The goal here was to use off-the-shelf components to build one ourselves.
The machine's construction was a solid metal frame inset with four 12-inch rollers used to move the mounted vehicle - essentially these are what made this a dyno. The vehicle sat on top and drove.
Each roller was connected to an electric motor for drive, brake, and torque/HP testing. The motors connected to Kelly motor controllers, which then connected to an Arduino. This was our way to communicate.
On the user's end, a Python program used our custom UART-based protocol to send and receive communications over serial. We used a Teensy microcontroller since it has eight serial ports, and received asynchronous communication from both directions.