My working experience at Mirasys Oy

Introduction

I work at Mirasys Oy in Finland as a Solutions Architect and DevOps Specialist. My role is not limited to drawing architecture diagrams or maintaining deployment pipelines. I work across the full software delivery lifecycle: application architecture, frontend and backend development, identity and access management, local development environments, CI/CD, Kubernetes infrastructure, GitOps, observability, security, testing, and production operations.

Mirasys builds video surveillance and video management solutions. The platform combines web applications, authentication, video streaming, device and recorder services, alarms, profiles, authorization, and supporting infrastructure. These parts must work together as one reliable system.

My responsibility is to connect those parts. I turn product requirements into technical solutions, implement important parts of the platform, and make sure the same software can move from a developer's laptop to test, staging, and production environments in a repeatable way.

My role at Mirasys

My role combines three areas that are often separated in larger teams:

• Solutions architecture

  I design how applications, microservices, data, authentication, authorization, events, and infrastructure work together.

• Software development

  I build production features across the React and TypeScript frontend, the Node.js IAM service, GraphQL integrations, and shared libraries.

• DevOps and platform engineering

  I maintain Kubernetes clusters, GitOps repositories, CI/CD pipelines, deployment configuration, observability, secrets, and local development tooling.

This combination is useful because architecture decisions are tested against real implementation and operational requirements. I do not only define how a system should work. I also build it, deploy it, monitor it, troubleshoot it, and improve it based on what happens in practice.

Designing the application platform

One of my main responsibilities is the architecture of the Mirasys microservices platform. The system includes services for identity, alarms, auditing, devices, digital sources, profiles, recorders, video channels, and video streams. It also includes GraphQL routing, service discovery, event messaging, authorization, databases, and web clients.

I define the boundaries between these components and how they communicate. Depending on the use case, this includes GraphQL APIs, REST endpoints, OAuth flows, JWTs, NATS events, Consul service discovery, and OpenFGA authorization checks.

For me, good architecture is not about adding more technology. It is about giving every component a clear responsibility, keeping integrations understandable, and making the whole system easier to change and operate.

Building Spotter Web and the shared frontend workspace

I maintain the unified frontend workspace for Mirasys applications. It contains Spotter Web, the Single Sign-On application, shared React components, shared business logic, utilities, tests, and build pipelines. The workspace uses React, Next.js, TypeScript, GraphQL, pnpm, and reusable internal packages.

My frontend work covers both product features and application foundations. I have implemented and improved areas such as live WebRTC video streaming, playback controls, timelines, camera selection, profile trees, alarms, and PTZ camera control. This includes GraphQL operations, state management, reusable hooks, loading and error handling, accessibility, internationalization, and automated tests.

Video applications have additional lifecycle challenges. A player must manage signaling, WebRTC ICE candidates, retries, cleanup, changing channels, and UI state without leaking resources or leaving stale connections. I work on these details because reliable streaming depends on the complete lifecycle, not only on rendering a video element.

I also maintain shared UI packages and common styling so Spotter Web and SSO use consistent components, colors, types, and behavior. Centralizing this work reduces duplication and makes changes safer across applications.

Identity, authentication, and authorization

Identity is one of the most important parts of the platform. I develop and maintain the Mirasys IAM service, built with NestJS, Fastify, TypeScript, GraphQL, PostgreSQL, TypeORM, JWT, OAuth, NATS, and OpenFGA.

My work includes user authentication, OAuth clients and authorization codes, access and refresh tokens, token revocation, multi-factor authentication, password management, application passwords, application token exchange, GraphQL APIs, service registration, migrations, and event synchronization.

Security features must also be practical to operate. I work on key validation, sensitive-field redaction, error handling, internal client configuration, database migrations, and tests around authentication flows. I treat identity as a platform capability used by every application, not as an isolated login screen.

For fine-grained authorization, I maintain the OpenFGA model, relationship tuples, tests, container image, and CI pipeline. I also automated synchronization of authorization models and model identifiers into deployed environments. This turns authorization changes into a versioned and repeatable delivery process instead of a manual production task.

Kubernetes and GitOps

I design and maintain the Kubernetes platform used by the development, test, mobile, and staging environments. The cluster repository contains Ansible automation for provisioning and upgrading nodes, together with Flux CD and Kustomize configuration for cluster infrastructure and applications.

The platform includes components such as cert-manager, CloudNativePG, Longhorn, Cilium, Sealed Secrets, metrics-server, ingress and Cloudflare Tunnel, Prometheus, Grafana, Alertmanager, Loki, and other supporting operators. I organize shared base configuration and environment-specific overlays so differences remain explicit and reviewable.

Application delivery is GitOps-based. Flux reconciles the desired state from Git, deploys Helm releases and Kustomize resources, and updates application images through automation. The repositories become both the deployment mechanism and an audit trail of infrastructure changes.

My Kubernetes responsibilities include:

• Provisioning, bootstrapping, upgrading, and troubleshooting clusters;
• Designing reusable Kustomize bases and per-environment overlays;
• Managing application configuration and encrypted secrets;
• Operating persistent storage, databases, networking, DNS, TLS, and tunnels;
• Maintaining image policies and automated deployments;
• Deploying monitoring, logging, dashboards, and alerting;
• Improving reliability through resource policies, health checks, and controlled rollouts.

The goal is simple: a deployment should be reproducible, observable, and recoverable. Git should explain what is running and why.

CI/CD and release engineering

I create and maintain Azure Pipelines for frontend applications, shared packages, backend services, authorization models, container images, tests, and code-quality checks. The pipelines build and test the software, run Sonar analysis, publish artifacts, build container images, and make those images available to the GitOps deployment flow.

I also work on release requirements outside Kubernetes. For example, I created a standalone SSO build flow for Windows packaging. It builds the workspace in dependency order, produces a symlink-free runtime, uses Next.js file tracing to keep the package small, and publishes a versioned artifact from CI.

This is an important part of my work: the architecture must support how customers actually install and run the product. A solution is not complete when it works only in the main development environment.

Improving developer experience

A microservices platform can become difficult to run locally. To reduce that friction, I maintain a Docker Compose development environment that brings together the application services and their dependencies.

The environment includes service containers, PostgreSQL, MongoDB, NATS, OpenFGA, Consul, GraphQL routing, reverse-proxy configuration, local TLS, environment templates, and development overrides. I also added service-specific Dev Containers so developers can work with a more consistent toolchain.

The target is a short path from cloning the repositories to running the system. Developers should be able to start the environment, replace selected container images with local source code, inspect services, and reproduce integration problems without rebuilding the entire platform manually.

I also maintain mock-data tooling in TypeScript. It generates realistic domain data and imports recorders, devices, video channels, profiles, alarms, and profile nodes through GraphQL. This supports frontend development, demos, integration testing, and repeatable test environments.

Quality and operational responsibility

I am responsible for more than feature delivery. I improve unit and component tests, TypeScript safety, GraphQL mocks, accessibility, error messages, internationalization, code coverage, and Sonar quality checks. I also review how a change behaves during deployment and operation.

When an issue crosses application and infrastructure boundaries, I follow it through the complete path: browser state, GraphQL request, authentication token, service logs, events, authorization checks, database state, Kubernetes workload, ingress, and deployment configuration.

This end-to-end ownership is a central part of my work at Mirasys. I help the team move from "it works on my machine" to a system that is understandable and supportable in every environment.

My responsibilities

In practical terms, I am responsible for:

• Translating product and business requirements into technical architecture;
• Designing integrations between web applications, microservices, identity, authorization, messaging, and infrastructure;
• Developing production features in React, Next.js, TypeScript, NestJS, and GraphQL;
• Owning IAM, OAuth, JWT, MFA, token management, application passwords, and OpenFGA integration;
• Maintaining shared frontend libraries and consistent application foundations;
• Building and operating Kubernetes environments with Ansible, Flux CD, Kustomize, and Helm;
• Maintaining GitOps application deployment and image automation;
• Designing CI/CD pipelines, container builds, quality gates, and release artifacts;
• Operating observability, networking, TLS, secrets, databases, and persistent storage;
• Improving local development with Docker Compose, Dev Containers, local TLS, and mock data;
• Diagnosing problems across application, platform, and delivery layers;
• Documenting systems and helping other developers use the platform effectively.

Skills demonstrated

My work at Mirasys demonstrates the following skills:

• Solution and microservices architecture;
• Full-stack TypeScript development;
• React and Next.js application architecture;
• GraphQL API integration and schema-driven development;
• WebRTC video streaming and PTZ control;
• NestJS, Fastify, PostgreSQL, and TypeORM;
• OAuth 2.0, JWT, MFA, IAM, and relationship-based authorization;
• OpenFGA authorization modeling and automation;
• Kubernetes cluster engineering and operations;
• GitOps with Flux CD, Kustomize, and Helm;
• Ansible infrastructure automation;
• Azure Pipelines, Docker, Sonar, and release engineering;
• Prometheus, Grafana, Alertmanager, and Loki observability;
• Developer platforms, Docker Compose, Dev Containers, and test-data tooling;
• Technical leadership and end-to-end system ownership.

Conclusion

My work at Mirasys is a practical combination of architecture, development, DevOps, and operations. I design the platform, implement core product and identity features, automate delivery, and maintain the infrastructure that runs the system.

The most valuable part of this role is the end-to-end perspective. A frontend decision can affect an API contract. An authentication decision can affect every service. A deployment decision can affect reliability, security, and the daily work of developers. I take responsibility for connecting these concerns and turning them into one maintainable solution.

This experience has strengthened how I approach complex systems: keep responsibilities clear, automate repeatable work, make changes observable, and treat software delivery as part of the product itself.