We iterate fast by keeping the inner development loop tight and the whole codebase in one place.

• Monorepo with workspaces and shared libraries, so frontend, backend and mobile evolve together

• Rust-based JavaScript/TypeScript toolchain for near-instant linting and formatting

• Parallel tasks across the whole workspace: a single command to lint, typecheck, test and build everything

We ship safely because correctness is enforced by tooling, not by good intentions.

• TypeScript everywhere with end-to-end type safety: a single source of truth for types across the whole system, shared by every app

• Type-aware linting with hundreds of strict rules and consistent, automatic formatting

• Automated testing throughout, from unit tests to an end-to-end testing setup scaffolded and ready to use whenever a project needs it

• A single quality gate (typecheck, lint, format, tests and build) that every change must pass before any deploy

https://github.com/quinck-io/blaze

Blaze is a Go minimal template that provides a starting point for new projects. It is designed to be a simple, yet powerful, foundation for building fast, idiomatic and maintainable HTTP services in Go. The template aims to not be opinionated, following the official Google conventions and the Go standard project layout. The main advantage of blaze is the 100% compatibility with the standard library, making it universal and compatible with all the Go http ecosystem (middlewares, routers, adapters, tracing, serverless…).

Features:

• Fast and very low overhead

• Utility-driven and flexible multi-entrypoint structure

• Simple to use without “hidden magic”

• 100% compatible with the Go http standard library

• Integrated structured logging

• Seamless AWS Lambda compatibility, optimized for fast cold starts

Stack:

• chi: http router (compatible with standard library) 

• chi/middleware: custom and integrated HTTP middlewares

• zerolog: structured logging

• golangci-lint: linter (custom configuration with strict rules)

Meddle is a platform designed to facilitate the connection between diverse data sources and destinations, processing and normalizing data in soft real-time. Meddle integrates sources and destinations with various industrial protocols or communication standards/technologies, including widely used open-source technologies. The software has two main components: the Gateway and the Cloud-based Software as a Service (SaaS). The Gateway is the atomic unit of Meddle, allowing the connection of multiple data sources to multiple data destinations. The SaaS component operates in the cloud, providing a management layer for multiple Gateways and their configurations, thus offering a comprehensive solution for data integration between diverse sources.

Features:

• Integration with industrial protocols: Snap7, Allen Bradley, BacNet, CAN, COAP, Melsec, Modbus, OPC-UA, Omron Fins, MTConnect

• Integration with open source technologies and communication standards: Apache Kafka, AWS SQS, Prometheus MongoDB, SQL, InfluxDB, MQTT, HTTP, REST

• Flexible plugin architecture

• Internal gateway data transform and rule engine

Stack:

• Python: core of the Meddle Gateway

• TypeScript: SaaS Frontend and backend

• Prometheus: monitoring and analysis

• Redis: SaaS datastream Pub/Sub

• WebSockets: SaaS datastream real time logs

• Docker: containerization (gateway and SaaS)

• AWS Cloud: SaaS infrastructure

  • S3, ECS (gateway deployment), EC2, Cognito (authentication)

The customer had a need for a system that would support the formulation of paints (consisting of 13 different mixtures) from a given color in RGB.

A database of about 20k formulated elements was available.

A feed-forward neural network-based system was implemented for the prediction of new formulas.

A dashboard making calls to a backend, which is based on a serverless asynchronous queuing system using AWS SQS and AWS Lambda, was implemented for the client's end use.

Events on the SQS bus trigger the invocation of an asynchronous worker executes the AI script and keeps track on a DB of each executed task and its status.

Requirements:

• DB of 20k elements (very sparse, various processing was done on the data such as Data preprocessing and Data Augmentation)

• Execution of asynchronous jobs via queues

• Monitoring of metrics to avoid issues

Stack:

• Python with Keras for Feed-forward Neural Network.

• NodeJS + Typescript for the worker managing the queues

• AWS SQS + AWS Lambda for asynchronous job management

• DynamoDB for data storage

• React + TS for the dashboard to visualize results

• AWS Cloudwatch for monitoring system usage and metrics (observability)

This experimental software is designed to manage a consistent, high-speed binary data stream from a line optical sensor that provides 3D inline inspection via a TCP socket connection. The system processes the data through analysis and filtering, manages alert mechanisms, and handles data streaming to a client. The latter is responsible for displaying charts and related information in real time, ensuring an effective and responsive user interface. 

The laser sensor is positioned above a material moving on a conveyor belt, performing a multi-point distance measurement. The output of the sensor can be simplified into a list of n numerical values (samples) indicating the distance to the material.

The software is strongly data-driven: all measurements, calculations, and analyses are specifically carried out for the type of data obtained from the sensor and, consequently, from the passing material.

Requirements:

• soft real-time measurements of each sample received from the sensor (very high speed, ~10.000 samples/s)

• web dashboard to visualize in real time the sample graph, manage sensor and user settings

• alerting system that triggers when measures exceeds user limits

Given the very high throughput and the concurrent nature of the software, we chose Go as the language for the server. All internal components communicate with each other via synchronized channels. The server runs a variety of concurrent operations:

• TCP sensor data ingestion 

• TCP sensor command dispatch

• REST API to communicate with the web dashboard

• data parsing, processing and measurement

• Websockets API to stream throttled data to the web dashboard

• check alerting based on measurements

Stack:

• Go: server language

• MongoDB: database to store alerting samples and user settings

• Svelte: web dashboard

• Grafana and Prometheus: internal software metrics and monitoring

This software serves as a centralized orchestration system for a network of spot welder microcontrollers within a local environment. It periodically retrieves data from each welder, enabling real-time monitoring and streamlining the aggregation of this data for future analysis. Designed for portability, the software is sold to users with the microcontrollers for spot welders, ensuring a seamless integration and management experience for users.

Requirements:

• connecting to multiple welder microcontrollers

• retrieving data from each welder REST API

• storing every single spot made by every welding machine, enabling later data analysis

• sending commands and settings to each welder

• managing welder settings backups

• visualizing connected welders, data and their details in a Web interface

• the entire software stack must be easily portable and installable in any server

• license key management

• Over the air updates for every user

Each welder exposes a documented Json HTTP API, enabling the server to easily retrieve and send data from those. 

The server is divided into 3 main components: API (business logic for the web dashboard), Daemon (welders manager) and Worker (single welder data scraper). Each component is decoupled and communicates with each other using an Event Bus.

When adding a new welder the user must specify its IP address, the Daemon then starts a Worker that scrapes data, stores it and manage the welder status.

The software is distributed as a Virtual Machine Disk (VMWare, VirtualBox and Hyper-V), containing the entire tech stack.

Stack:

• React: web dashboard

• Node.js and TypeScript: API, Worker and Daemon

• Go: OTA update manager, License key management

• MongoDB: main database for business logic and welder data

• Redis: cache, Event Bus

• NGINX: reverse proxy

• Docker: containerization for each component

• Debian: OS delivered in the final virtual disk

This project addresses the critical need to establish a computerized database dedicated to anti-money laundering compliance. It aims to facilitate data and information retention in accordance with regulatory guidelines, automate risk profile calculations, feed into the automated analysis system for abnormal operations, and automate the annual self-assessment process.

Features & Metodolgies:

• Data Warehousing Solution: the project implements a comprehensive data warehousing solution tailored for anti-money laundering compliance.

• REST Interface: The system provides interaction capabilities through a REST interface, ensuring seamless communication with other components.

• Microservices Architecture: Leveraging microservices architecture to exploit scalability and flexibility.

• Domain-driven development (DDD): Aligning software design with business domain.

• Database Management: Utilizes TypeORM and AWS RDS with Aurora PostgreSQL for efficient database management and storage.

• KYC Evaluation Module: dedicated module for KYC evaluation, enabling organizations to assess customer identities, verify documentation, and flag suspicious activities.

Technology Stack:

• Nest.js: High level framework for building efficient and scalable server-side applications in Node.js

• AWS Lambda: Serverless computing service for running code without provisioning or managing servers.

• TypeORM: ORM (Object-Relational Mapping) library for TypeScript and JavaScript, simplifying database management.

• AWS RDS (Aurora PostgreSQL): Managed relational database service by AWS for seamless database operations.

• AWS SAM: Serverless application model for defining and deploying serverless applications on AWS.

• GitLab CI: Continuous integration and delivery platform for automating testing and deployment processes.