My professional career journey

Introduction

I have worked in the IT industry since my final year at university. My career has taken me from PHP development to technical leadership, business-critical microservices, independent consulting, solution architecture, and DevOps.

Each stage added a different perspective. At Grey Neuron, I grew from Software Developer to Technical Lead and CTO. At International Automobile Association Inc. (IAA), I maintained and modernized a long-running business platform. At ParkMan Oy, I owned critical billing workflows and contributed to automatic camera-based parking. Since 2021, I have also operated as a Finnish sole trader, providing independent IT consulting and end-to-end technical delivery.

The technologies have changed, but my approach has remained consistent: understand the business problem, keep responsibilities clear, automate repeatable work, and take responsibility for the solution after it reaches production.

Grey Neuron Ltd - from developer to CTO

I worked at Grey Neuron Ltd from 2009 to 2020. I joined during the final year of my university studies as a Software Developer, later became a Technical Lead, and eventually served as CTO.

This was where I built my professional foundation. I developed websites, customer portals, administration systems, and custom business applications using PHP, Yii 1, Yii 2, WordPress, and relational databases.

My development responsibilities included:

• Designing application and database architecture;
• Building frontend, backend, account, and administration features;
• Implementing authentication, authorization, validation, and business workflows;
• Integrating payments, email, storage, APIs, and external services;
• Creating scheduled tasks and command-line processes;
• Improving application performance, security, and maintainability.

I also managed Linux servers and customer hosting environments with DirectAdmin and cPanel. This included web servers, databases, DNS, email, SSL certificates, backups, scheduled tasks, security updates, migrations, incident response, and recovery.

That operational experience became the foundation of my later DevOps work. Before working with containers and Kubernetes, I learned the underlying concerns directly: processes, permissions, filesystems, networking, certificates, databases, backups, and service recovery.

As Technical Lead, I moved from implementing individual features to designing complete solutions, reviewing code, planning work, mentoring developers, and resolving difficult technical problems. I also worked with customers to clarify requirements and explain technical tradeoffs.

As CTO, I became responsible for technical direction across development and operations. I selected frameworks and engineering practices, designed important systems, led developers, reviewed critical code, managed infrastructure, and considered project risk, maintainability, security, delivery commitments, and cost.

I moved to Finland in 2018 and continued working with Grey Neuron remotely for two more years. This strengthened my written communication, remote leadership, and ability to coordinate technical delivery across countries and time zones. I completed my time at Grey Neuron in 2020 when I joined ParkMan Oy.

Consulting for International Automobile Association Inc.

My work with International Automobile Association Inc. covers the complete technical lifecycle of its international driving permit services. I maintain established systems, develop newer customer services, design integrations, and operate the infrastructure that moves changes into production.

The core platform is a mature PHP and Yii2 system containing the public website, permit application process, customer accounts, administration tools, shared business logic, APIs, scheduled jobs, document workflows, and database migrations.

Working with a long-running business platform requires careful modernization. Existing workflows cannot simply stop while a newer service is being developed. I preserve stable business logic, improve high-risk areas incrementally, and expose controlled APIs so newer applications can reuse trusted capabilities.

My work includes:

• Maintaining application, order, customer, pricing, and payment workflows;
• Improving file uploads, permit images, document data, and email notifications;
• Developing authenticated JSON APIs for pricing and applicant creation;
• Validating multipart data and handling customer document uploads;
• Maintaining multilingual content and public information;
• Protecting backward compatibility and sensitive customer data.

Alongside the core platform, I developed a React and TypeScript service for generating the printable international driving permit booklet. I also built a Next.js application-tracking portal that verifies Cloudflare Turnstile and calls the upstream status service securely from the server.

For newer customer experiences, I work with Next.js, React, TypeScript, multilingual content, pricing, permit verification, contact workflows, and a multi-step application and checkout process. These interfaces connect to the established applicant platform rather than duplicating its business logic.

I also take responsibility for delivery and operations. The applications are containerized and deployed through CI/CD and GitOps. I maintain Kubernetes bases and environment overlays, Flux image automation, Kustomize configuration, encrypted secrets, staging and production environments, and Cloudflare Tunnel connectivity.

This work demonstrates an important part of my consulting approach: modernization is not only a frontend redesign. It includes APIs, data, security, document handling, deployment, configuration, and long-term production support.

Senior Backend Developer at ParkMan Oy

I worked at ParkMan Oy in Finland as a Senior Backend Developer from 2020 to 2021. My main responsibility was ownership of the Billing Service, a critical microservice responsible for turning parking activity into reliable and traceable financial workflows.

Billing is not a single payment request. A production billing platform must handle asynchronous callbacks, temporary provider failures, duplicate events, retries, invoices, unpaid cases, and reconciliation without creating incorrect state or charging a customer twice.

I designed and maintained billing domain logic, payment-provider integrations, service contracts, state transitions, retries, and operational error handling.

One of my main integrations used PayPal Braintree. I worked on the complete payment lifecycle: creating transactions, validating provider responses, processing callbacks, and recording successful or failed outcomes inside ParkMan's platform.

I also built integrations for Finnish invoicing and Intrum debt collection. These workflows transferred validated billing and customer data to external financial systems and processed the returned status changes. Because incorrect or duplicated information could directly affect a customer, I focused on traceability, idempotency, validation, and deterministic processing.

For automated payments, I used AWS Step Functions to model the process as an explicit state machine. The workflow could coordinate multiple steps, make decisions, wait when required, retry temporary failures, and route unsuccessful payments into the correct follow-up process.

I also contributed to the Parking Service and its automatic camera-based parking workflows. Camera events needed to be associated with the correct vehicle, customer, parking location, and session before the result could move into pricing and billing.

This work connected physical-world events with several independently deployed services. It required clear service boundaries, reliable APIs and events, explicit data ownership, and careful failure handling.

I also contributed to DevOps and GitOps practices around the services. Backend ownership continued through builds, tests, container delivery, deployment configuration, monitoring, and production troubleshooting.

My ParkMan experience strengthened how I design distributed systems: make states visible, expect retries, treat duplicate events as normal, and design every critical workflow with a recovery path.

Operating as a Finnish sole trader

I have operated as a Finnish sole trader, or yksityinen elinkeinonharjoittaja, since 2021. Through my Toiminimi, I provide independent IT consulting, solution architecture, software development, DevOps, and hosting services.

Independent consulting brings technical and commercial responsibility together. I need to understand the customer's real goal, define an appropriate scope, select a maintainable solution, deliver it, operate it, and explain the cost and tradeoffs clearly.

Depending on the project, my work may include:

• Solution and microservices architecture;
• PHP, Yii, WordPress, Node.js, and TypeScript development;
• React, Next.js, NestJS, REST, and GraphQL;
• SQL and NoSQL database design;
• Authentication, authorization, payments, and external integrations;
• Docker, Kubernetes, Flux CD, Kustomize, Helm, and GitOps;
• CI/CD pipelines, automated releases, and container delivery;
• Linux, DirectAdmin, cPanel, DNS, email, TLS, backups, and security;
• Technical SEO, performance, accessibility, and production support.

Not every project requires the same stack. Some customers need a cloud-native microservices platform, while others need a reliable PHP application or a well-managed Linux hosting environment. I choose technology based on the business and operational requirements rather than forcing every customer into the same architecture.

Running a Toiminimi also means managing proposals, agreements, scheduling, invoicing, expenses, customer communication, and long-term relationships. This makes technical cost visible. Every unnecessary dependency or operational step eventually becomes a maintenance cost for the customer.

Trust is equally important. Independent consulting may involve access to production systems, credentials, customer information, and confidential business processes. I take responsibility for secure access, careful handling of data, clear documentation, and reliable support.

My responsibilities across these roles

Across Grey Neuron, IAA, ParkMan, and my Toiminimi, my responsibilities have included:

• Translating customer and product requirements into technical architecture;
• Developing backend, frontend, APIs, databases, and integrations;
• Designing microservices, events, stateful workflows, and service boundaries;
• Owning business-critical billing and payment processes;
• Maintaining and modernizing long-running PHP and Yii systems;
• Building newer services with React, Next.js, and TypeScript;
• Managing Linux hosting, databases, DNS, email, TLS, backups, and recovery;
• Creating CI/CD, containers, Kubernetes, and GitOps delivery workflows;
• Supporting staging and production environments;
• Investigating issues across application, integration, and infrastructure layers;
• Leading developers and communicating technical decisions;
• Taking responsibility from initial design through production operation.

What these experiences taught me

Grey Neuron taught me how to grow from implementation into leadership and how to support software throughout its operational life.

IAA taught me how to modernize a mature platform without disrupting the business that depends on it.

ParkMan taught me how to design financial and event-driven microservices where correctness, idempotency, and recovery are essential.

Running my Toiminimi taught me to connect technical decisions directly with customer value, trust, maintenance cost, and commercial responsibility.

Together, these experiences shaped my current approach as a Solutions Architect and DevOps Specialist. Architecture, development, delivery, and operations are not separate concerns. They are different parts of the same product lifecycle.

Conclusion

My career has progressed from PHP development and Linux hosting to technical leadership, critical microservices, independent consulting, Kubernetes, and GitOps.

The most valuable part of this journey is the end-to-end perspective. I can understand an existing business platform, design a modernization path, implement the application and integrations, automate its delivery, and support it in production.

Technology continues to change, but I rely on a consistent set of principles: keep responsibilities clear, make important states observable, automate repeatable work, design for failure and recovery, and build solutions that people can maintain after the first release.