Anthony Chiboucas

Just don't .NET. It was a failed idea from the start. Node and javascript are easier to learn, with much wider adoption, and more active communities.

.NET is an old experiment in using a markup language to separate the UI from the business logic. The idea was that this would allow a small team of hyper-competent engineers to build the tooling and code for a large team of less-skilled front-end developers to leverage. In practice, leveraging that customized UI markup requires understanding and adjusting the underlying code. The result is that any UI change requires a hyper-competent .NET engineer.

However, many larger companies bought into it a long time ago, and now have a hard dependency on old monolithic .NET ecosystems, and they do need .NET developers to maintain them.

So, you can get a well paying .NET job without much difficulty. However, you'll neither like it, nor be doing anything interesting. There's no growth here, only a very long slow death of .NET (that'll probably take another 20 years).

Node and Javascript are sticking around, and still growing.

There isn't a single stack or framework which is indicated for a problem like this. The important thing is that you are comfortable with the framework you choose.

Ultimately, you're creating a pattern that is common all over the web: API → server → data → browser. The biggest challenge you will encounter in this endeavor is creating the charts, so pick that first. I'd suggest looking more closely at Chart.js first, but there are many other options.

In choosing your stack, work backward from your charting tool: 1. What will be the easiest and most flexible way to get the data into the chart? 2. What will be the easiest and most flexible way to structure the data for the chart?

Then, you can start picking the rest of your stack. Really, you don't need all the wizzbang of Lumen and Vue and microservices. Each library or framework you add will add complexity, reducing performance and stability, and adding time to develop and troubleshoot. Use the fewest libraries possible to keep your code small, simple, and lightweight. With a tool like Chart.js, you need only a way to deliver some html/css/js to a browser, data to the js, and collect data from an api POST.

If you really want to strip all of that down to something super-simple, and already almost done, "IoT" POST data to google-sheets, then retrieve it for your chart directly from the sheet. No server needed, just some browser code. It comes with the benefit that most of your code will be in javascript: update browser cache from sheet, structure for chart, update chart. However, if there is a requirement to have reactive (close to real-time updates without reloading page) charts, you'll have to use Node.js. Vue could do it, but it will be a painful journey getting it working cleanly.

Lastly, IoT is rarely standard API calls. It is almost always in MQTT, which is a completely different rabbit-hole I advise you avoid for now.

While I haven't use AWS Code myself, I have a few years of experience with Ansible.

• It doesn't play nice with Windows.
• Dependency hell is real.
  • Playbooks and tasks are built off of other playbooks and tasks, which are built off other playbooks and tasks. Actually figuring out what Ansible is really doing, to install mysql for instance, requires digging several layers deep into other ansible scripts.
• Debugging is a chore.
  • When a dependency needs updating, or there's a newer pattern for install/update of OS and libs, it can be very difficult to find what parts of your ansible script need updating, and where to update. Often it's in one of those playbooks you've built from, and you're left waiting for them to update, or taking on that whole playbook yourself.

You can install and run Neo4j Community Edition for free locally, or on a linux server. It's GPLv3 open source, so you can use it commercially. There are some contraints to the community edition, like no clustering, and no more than 34 million nodes, but it'll be hard to need those features until you're big. If it turns out you do need Enterprise, they have a startup plan (I think it's free too) for companies with less than 50 employees: neo4j.com/startup-program.

What you're really choosing between is price, language, and support:

PRICE

• Neptune: At least $1000 a year, though you'll likely be spending closer to $5000 a year when you're live.
• Neo4j Community: Free for commercial use.
• Neo4j Enterprise: (free?) for small companies. $35,000? one-time license fee for big companies.

Support

• Neo4j: Large active community, both on their forums and in stackoverflow. It's easy to find and direct-message people building and working on the engine.
• Amazon: ...well, it's Amazon.

Language

To compare the languages, I'll give a sample for getting a node by label "person" who's name property is "Bob", finding "children" nodes, and returning the email property from the children as a list.

Neptune Gremlin

g.V().hasLabel("person").has("name","Bob")
in("children").hasLabel("student").values("email")

Neptune SPARQL

I don't have a clue, it's so esoteric with no user-friendly documentation or guides.

Neo4j Cypher

MATCH ( :person {name: "Bob"})<-[:children]-(x :student)
RETURN x.email

Good software, bad marketing. Bait-and-switch (beware).

While Freshdesk has a great UI, and is a feature-rich service, the truth behind the advertising leaves much to be desired. While their software is good, the pricing model isn't, and their marketing is intentional bait-and-switch. The features listed on each pricing tier are expanded upon here: freshdesk.com/features. Once you buy, and ask what's up, the support will tell you to upgrade for that feature, and link you to a page that isn't linked to from anywhere on their site: freshdesk.com/helpdesk-features, as justification.

As an example, $15/agent/month includes, "SLA Management," which is described from their features page as including every SLA feature, including basic things like SLA email notifications, reminders, escalation policies. You know, what anyone would think of as "SLA Management." However, none of those features are actually included in that price plan. To even get email notifications of SLA violations, or have your SLA respect office hours, you'll have to pay $50/agent/month. Worse, there is no way to discover this until after you've paid and spent time getting everything set up.

Building and visualizing a graph doesn't require a complex engine. It could be done with Lucidchart, or even basic tools like Arrow Tool, or mind map tools like CMap, if a UI for a graph is your only goal.

That said, there are a lot of things you can only do with a real graph database.

• Run applications on the data.
• Import data to create a graph.
• Search and query the graph, to filter to specific paths and nodes.
• Run graph algorithms to find things like shortest path, betweenness, and community detection.

If you will need some of the features of a graph database, and a chart of your graph isn't enough, Neo4j will be the best avenue to explore. One word of caution, it has a little bit of a learning curve, but it is SO worth it. Graph databases, especially good ones like Neo4j, are an indescribably powerful tool for organizing information (any information).

GraphDBs are to RelationalDBs, what RelationalDBs are to Spreadsheets. But GraphDBs are way easier to learn.