Bohdan
Vilzhanovskyi
I build and evolve backend systems running in production.
18+ years in production, not tutorials.
Senior Backend Engineer & Tech Lead (PHP, JS)
Enterprise systems - telecoms, IoT, SaaS, high-load cloud platforms
18+ years of enterprise PHP.
about
Engineer by craft.
Leader by experience.
I've been building software since 2006 - from early PHP projects to modern enterprise systems across telecom, SaaS, IoT, e-commerce, and high-load platforms. I work systematically, think architecturally, and take ownership from requirements to production.
I combine hands-on engineering with technical leadership: I design systems, refactor critical areas, build maintainable architecture, raise the engineering bar, and help teams move faster without losing quality.
A big part of my work is making systems and teams predictable - clarifying requirements, aligning technical decisions, and stabilizing legacy areas that slow teams down.
skills
Deep stack.
Proven in production.
18 years across the full stack - from bare-metal PHP to cloud-native microservices.
- Core backend language for designing and building high-load, scalable production systems for 18+ years.
- Architected and implemented backend architectures, including APIs, microservices, and event-driven systems.
- Led modernization of legacy systems, improving performance, reliability, and maintainability.
- Defined backend standards, reviewed architecture decisions, and contributed to technical strategy.
- Applied across enterprise-grade platforms, telecommunications and billing systems, IoT and video analytics solutions, high-load event processing and automation systems, SaaS platforms, and large-scale e-commerce applications.
- Used to design and build structured backend systems for enterprise and high-load applications.
- Applied for modular architecture, clean business logic separation, and long-term maintainability.
- Designed and implemented APIs, service layers, and integrations within service-oriented and microservices-based systems.
- Experienced with dependency injection, framework conventions, and production-grade application support.
- Worked across multiple Symfony versions (3-5), including migrations and modernization of legacy systems.
- Extensive experience with enterprise and long-lived systems built on Zend Framework and later Laminas.
- Designed and developed custom components, modules, and reusable architecture layers for complex backend systems.
- Led modernization and refactoring of legacy codebases, including gradual migration strategies and system evolution.
- Applied in systems where stability, backward compatibility, and controlled evolution are critical.
- Worked on large-scale platforms with complex business logic, integrations, and long-term maintenance requirements.
- Used for designing data access layers in enterprise and high-load PHP applications with complex domain logic.
- Designed entity models, repositories, and data access patterns aligned with domain-driven design principles.
- Optimized ORM-heavy codebases, improving query performance and reducing database overhead in production systems.
- Balanced ORM abstractions with performance-aware SQL decisions, including custom queries and query tuning.
- Applied in large-scale systems requiring maintainability, scalability, and efficient data processing.
- Used for building lightweight backend services and AWS Lambda functions for async processing and integrations.
- Implemented serverless workflows, event-driven handlers, and integration logic in production environments.
- Applied for background jobs, automation tasks, and service-side scripting where low-latency and scalability were required.
- Integrated with AWS services (SQS, EventBridge, Lambda) as part of distributed and event-driven systems.
- Used as a practical part of the backend stack, primarily for serverless and integration-focused workloads.
- Designed and implemented integrations with internal and third-party systems using REST and SOAP APIs.
- Defined API contracts, request/response structures, and ensured backward compatibility in evolving systems.
- Implemented error handling, retries, idempotency, and resilience patterns for production integrations.
- Worked with real-world business integrations, including unreliable external systems, timeouts, and edge-case handling.
- Led debugging and troubleshooting of complex integration issues in production environments.
- Worked in large-scale distributed systems with 50+ microservices in production environments.
- Designed and developed services with clear responsibility boundaries, service isolation, and well-defined interfaces.
- Applied messaging and event-driven communication patterns for inter-service interaction and asynchronous processing.
- Handled real-world challenges including service coordination, data consistency, retries, and failure scenarios.
- Pragmatic approach to microservices: decomposing systems where it improves scalability, reliability, and delivery speed.
- Extensive experience using JavaScript across frontend and backend-adjacent systems in production environments.
- Developed complex UI logic, admin panels, and integration-heavy interfaces in legacy and modern applications.
- Worked with a wide range of libraries and frameworks (jQuery, jQuery UI, RequireJS, DataTables, and others).
- Integrated frontend with backend services, handling asynchronous flows, API communication, and real-time updates.
- Strong focus on practical, production-ready solutions rather than isolated component-level work.
- Developed full frontend applications using Vue.js (v2), including complete SPA implementations.
- Built admin panels and user interfaces integrated with backend services and APIs.
- Used Vue as a practical UI layer in backend-driven architectures, focusing on functionality and integration.
- Worked on production systems where Vue was part of a larger system, not isolated frontend projects.
- Applied for gradual frontend modernization and improving user experience in existing systems.
- Extensive experience building and maintaining complex frontend interfaces in long-lived enterprise systems.
- Developed dynamic UI logic, admin panels, forms, widgets, and integration-heavy browser interactions.
- Worked with legacy frontend architectures, ensuring stability, maintainability, and gradual modernization.
- Handled real-world UI challenges including state management, async interactions, and backend-driven interfaces.
- Strong background in production systems with complex business logic on the frontend layer.
- Solid practical experience building and maintaining production-ready interfaces for web applications and admin systems.
- Focused on clean layouts, responsive behavior, and maintainable structure rather than visual design complexity.
- Comfortable implementing UI from requirements, including forms, dashboards, and backend-driven interfaces.
- Familiar with modern CSS capabilities (responsive design, media queries), without reliance on heavy CSS frameworks.
- Positioned as a pragmatic frontend capability within a backend-focused engineering profile.
- Extensive experience with legacy frontend architectures and utility-based JavaScript ecosystems (Underscore.js, RequireJS, and similar libraries).
- Worked with modular JavaScript organization, dependency management, and client-side logic in large-scale production systems.
- Built and maintained complex UI logic, data transformations, and view-layer helpers in long-lived applications.
- Experienced in supporting and evolving legacy frontend codebases as part of backend-driven systems.
- Strong understanding of how frontend architecture evolved from utility-based patterns to modern frameworks.
- Designed and implemented cloud-based systems using AWS Lambda, SQS, and S3 for asynchronous processing, messaging, and storage.
- Built event-driven workflows and background processing pipelines for integrations, automation, and high-load systems.
- Worked with AWS IoT services, including Device Shadow, for managing device state and synchronization in distributed environments.
- Applied asynchronous communication patterns (queues, event-driven flows) to decouple services and improve scalability and reliability.
- Designed solutions leveraging managed services to reduce operational complexity and improve system resilience.
- Worked with Azure SQL and Synapse for data processing, reporting, and analytics in enterprise environments.
- Designed and implemented database structures including external tables, views, materialized views, and stored procedures.
- Built and optimized data workflows and pipelines for reporting, integrations, and data-driven applications.
- Worked with Azure Event Hub for event ingestion and streaming data processing in distributed systems.
- Integrated data-layer and event-driven components as part of production systems handling asynchronous and high-volume data flows.
- Focused on performance, maintainability, and efficient data access in real-world enterprise environments.
- Used for local development, service packaging, and reproducible environments.
- Worked with containerized services as part of backend workflows and deployment processes.
- Comfortable running and configuring multi-service environments (e.g., databases, queues, supporting services).
- Comfortable adopting and applying Docker when needed, including in production and deployment workflows.
- Familiar with infrastructure automation and configuration-driven environment setup.
- Worked with infrastructure-related workflows and deployment processes involving automation.
- Comfortable understanding and adapting existing infrastructure configurations in team environments.
- Familiar with data-flow based integration and pipeline-oriented processing.
- Worked with data movement, transformation, and orchestration in integration-heavy environments.
- Used as a supporting component in data processing and integration pipelines in production systems.
- Designed and maintained CI/CD pipelines for automated build, testing, and deployment in production environments.
- Worked with GitLab CI/CD and GitHub-based workflows for delivery automation across backend services.
- Built and supported release processes, pipeline-based deployments, and repeatable delivery workflows.
- Ensured reliable and consistent deployments as part of production system ownership.
- Configured and managed production web stacks including nginx and Apache for application hosting, routing, and reverse proxying.
- Worked with HAProxy / nginx for load balancing, traffic distribution, and handling high-load backend services.
- Implemented advanced load balancing strategies, including health checks and dynamic routing based on runtime metrics (e.g., agent-based backend control).
- Designed and maintained request routing, proxy layers, and service exposure in production environments.
- Handled real-world production concerns including debugging, performance tuning, and reliability of server-side delivery.
- Strong focus on practical backend ownership, including how applications behave under real traffic.
- Worked with virtualization platforms for infrastructure setup, service isolation, and environment management.
- Used for development, testing, and hosting of backend services and supporting systems.
- Built and maintained multi-service environments including databases, monitoring, and infrastructure components.
- Applied as part of practical infrastructure ownership, understanding how systems run beyond application code.
- Comfortable managing and troubleshooting virtualized environments in real-world scenarios.
- Core relational database used across multiple production systems over many years.
- Strong experience with schema design, indexing strategies, query optimization, and performance tuning.
- Worked with replication setups (master-replica), including read/write separation and scaling under real traffic.
- Designed and used views, partitioned tables, and optimized data structures for performance and maintainability.
- Analyzed execution plans and optimized complex queries in high-load environments.
- Troubleshot production issues including slow queries, locking, and performance bottlenecks.
- Applied in systems with significant traffic, focusing on reliability, consistency, and operational stability.
- Working experience with PostgreSQL in backend systems where it was part of the technology stack.
- Used for standard relational workloads, queries, and integrations within application contexts.
- Comfortable working with existing schemas, queries, and database structures in production systems.
- Applied as part of broader backend database experience across multiple systems.
- Used for search-oriented and indexing-heavy use cases where relational databases were not sufficient.
- Worked with indexing strategies, query design, and data shaping for search functionality.
- Integrated Elasticsearch into backend systems for search and data retrieval scenarios.
- Applied as part of real production systems with search and filtering requirements.
- Used for asynchronous processing and decoupled communication between services.
- Worked with message-based workflows, including background jobs, retries, and failure handling.
- Applied in distributed systems where reliability, queue-based processing, and integration flows were required.
- Comfortable working with messaging patterns as part of event-driven and backend architectures.
- Applied OOP, SOLID, and domain-driven design (DDD) principles in long-lived production systems.
- Designed system structure, boundaries, and responsibilities with focus on maintainability and scalable backend architecture.
- Used design patterns from GoF and enterprise application architecture (Fowler) to solve real-world structural and behavioral problems.
- Strong understanding of when patterns add value versus unnecessary complexity.
- Influenced by practical engineering principles from industry literature (e.g., Code Complete, Fowler), applied in real production environments.
- Created architecture documentation to make complex systems understandable and delivery more predictable.
- Documented system design, boundaries, data flows, and technical decisions for long-lived production systems.
- Used structured approaches (e.g., IEEE 1016-style design documentation) to capture architecture and decision rationale.
- Supported planning, onboarding, and handover through clear and maintainable technical documentation.
- Strong focus on communication of architecture, not only implementation.
- Performed security-focused code and architecture reviews using OWASP principles and checklists.
- Designed systems with security in mind, including authentication, access control, data handling, and safe service interactions.
- Identified common vulnerabilities and unsafe patterns early in development and production environments.
- Applied practical security measures to reduce real-world risks without overcomplicating system design.
- Conducted code reviews focused on security risks, weak assumptions, and vulnerability patterns.
- Applied production hardening practices, including safer configurations, deployment discipline, and reducing operational risk.
- Considered real-world threat scenarios, focusing on system exposure, failure points, and risk mitigation.
- Contributed to improving team awareness and engineering standards around secure development.
- Used structured logging as a core tool for understanding system behavior in production environments.
- Worked with centralized logging systems (e.g., Graylog) for aggregation, search, and analysis of application and integration logs.
- Applied logging practices aligned with OWASP recommendations, including proper log levels, security-relevant events, and safe data handling.
- Used logs for debugging production issues, tracing integrations, and improving operational visibility.
- Strong focus on actionable logging that supports incident response and system observability.
- Used metrics to monitor system behavior, detect regressions, and track key operational signals in production systems.
- Worked with Prometheus-based monitoring, including exporters for application, database, and infrastructure metrics.
- Designed and used metrics to improve visibility of system health, performance, and capacity.
- Applied metrics as part of building predictable and observable backend systems.
- Worked with alerting systems based on Prometheus Alertmanager and Grafana.
- Configured alerts to detect failures, degradation, and abnormal system behavior in production environments.
- Focused on practical alerting: reducing noise, improving signal quality, and supporting effective incident response.
- Used alerting as part of broader observability and production monitoring workflows.
- Used logs, metrics, and alerts to investigate incidents and understand system behavior under real conditions.
- Focused on reducing time to detection and improving clarity during production issues.
- Combined observability signals to support debugging, incident response, and system reliability.
- Used load testing tools (k6, JMeter) to simulate traffic and analyze system behavior under load.
- Tested performance characteristics, bottlenecks, and system limits in controlled environments.
- Applied results to improve scalability, reliability, and production readiness.
- Participated in hiring processes, including technical interviews and candidate evaluation.
- Conducted interviews with focus on engineering depth, real-world reasoning, and communication.
- Evaluated candidates based on practical judgment, problem-solving ability, and team fit.
- Contributed to maintaining team quality through consistent technical standards and hiring decisions.
- Mentored engineers through technical guidance, code reviews, context sharing, and growth conversations.
- Conducted regular 1:1s, providing feedback and supporting performance, stability, and team communication.
- Worked with structured development practices, including growth planning (PDP) and long-term capability building.
- Helped improve team effectiveness, stability, and engineering maturity over time.
- Defined and supported engineering standards, including coding guidelines, review expectations, and technical consistency.
- Contributed to building shared quality expectations across teams for scalable and maintainable systems.
- Took ownership of delivery from planning to production outcomes, ensuring reliability and alignment with business goals.
- Focused on predictable delivery and real-world execution, not only implementation.
- Worked on technical planning, breaking down tasks, and structuring delivery work.
- Performed estimations based on practical experience, system complexity, and real constraints.
- Focused on predictable delivery and aligning technical work with business expectations.
- Took part in moving work from planning to production outcomes.
- Worked in cross-team environments, supporting communication between engineering, product, and stakeholders.
- Helped align technical decisions with broader system context and business needs.
- Ensured smooth collaboration across teams involved in delivery.
- Worked on stabilizing legacy systems, improving reliability and reducing production risks.
- Contributed to process design, team workflows, and development practices.
- Focused on building predictable, maintainable, and scalable delivery processes.
- Used unit tests to support reliable delivery, safe changes, and long-term system stability.
experience
18 years.
Enterprise scale.
From freelance PHP to distributed cloud platforms serving US, Canadian, and Swedish clients.
Worked on enterprise systems for incident management, IoT camera processing, and automation workflows. Designed service architecture and system modules, refactored legacy code, and improved overall system structure. Supported reliable delivery through CI/CD workflows and unit testing, enabling safer changes and long-term system stability. Worked with complex data layer, including queries, views, stored procedures, and triggers.
Worked in an outsourcing environment, leading multiple PHP teams and supporting delivery across various client projects. Defined technical direction, improved system architecture, and established engineering standards across teams. Supported engineers through mentoring, feedback, and knowledge sharing, contributing to team growth and capability development. Participated in hiring, technical interviews, and pre-sales activities, helping shape project direction and team composition. Contributed to project development where needed, supporting teams in solving complex technical problems.
Worked on large-scale telecom platforms delivered for a Canadian client (Hostopia), covering services such as hosting, email, fax, and customer-facing systems. Participated in both modernization of legacy systems and development of new services using Symfony. Worked in a distributed environment with a microservices-based architecture (50+ services), supporting complex integrations and system interactions. Took technical leadership within the team, supporting less experienced engineers, sharing knowledge, and contributing to solution design. Contributed to backend development as well as frontend work on a Vue.js-based single-page application. Supported long-term evolution of production systems, including refactoring and system improvements.
Worked in an outsourcing environment, delivering a large e-commerce platform for a Swedish client. Started the project from scratch, taking full ownership of system design and technical implementation. Established trust with the client through direct technical interviews, contributing to securing the project engagement. Worked in both remote and on-site settings, including periods of collaboration directly from the client’s office. Worked across the full stack, from server setup and infrastructure to backend development using both plain PHP and Zend Framework. Developed and supported e-commerce functionality, including payments, integrations, and core system logic.
Worked in an outsourcing environment, contributing to multiple PHP-based projects including Artel, School-Maps, Outcomecomposer, TheBoredGame, and i-Memorial. Took a leading role in development on several projects, including system design, task distribution, code review, and coordination within small teams. Developed backend functionality, integrations, and business logic, as well as client-facing features and interactive applications. Worked on full-cycle development of new systems, supporting implementation, debugging, and ongoing improvements across multiple projects.
Worked on a large-scale advertising platform (banner network) with advanced statistics, revenue tracking, and traffic management. Handled high traffic volumes, processing data for 10-16M unique hosts per month, requiring efficient data handling and performance optimization. Developed backend logic and contributed to system architecture, data processing, and performance optimization for ad delivery and reporting.
Worked for a local telecommunications provider, developing systems for cable TV billing and service management, including solutions for hospitality (hotel) environments. Built backend functionality and integrations for managing subscriber accounts, service packages, and operational workflows. Developed administrative tools and systems for handling documentation, user management, and internal processes. Contributed to system design, implementation, and ongoing improvements across production systems.
projects
Systems that
shipped and scaled.
Selected work from 18 years of real-world engineering.
Enterprise ecosystem of backend services, UI modules, and automation workflows for incident management, IoT camera processing, and operational coordination. Included multiple services and microservices, service integrations, and UI-facing modules across AWS and Azure environments. Focused on architecture, refactoring, delivery stability, and long-term system evolution in production.
Smart parking platform used in hotels, healthcare, and enterprise facilities, combining hardware integrations and backend systems. Joined the project to stabilize and improve an existing system, focusing on refactoring, code quality, and making the platform more reliable in production. Worked on booking flows, operational logic, and administration tooling as part of ongoing system evolution.
Enterprise hosting platform for managing customer accounts, services, and integrations across multiple telecom providers. Worked on backend development and integrations, supporting complex domain logic, service provisioning, and interaction with external systems (REST/SOAP). Handled account management, service configuration, and operational workflows in a large production environment.
Enterprise fax platform used by major US and Canadian telecom providers. Worked on stabilization and modernization of the system, including migration from legacy PHP codebase to a Symfony-based backend with a Vue.js SPA. Handled multiple integrations with internal company services and external providers, supporting complex communication workflows. Worked with asynchronous processing using message queues, contributing to reliable data flow and system coordination. Focused on production stability, refactoring, and long-term system evolution.
Company website with the possibility of dynamically constructing all possible pages. Responsibilities included application development, communication with the customer, determining task priorities, task estimation, creating task specifications, distributing tasks between team members, code review, deployment, technical documentation, and dev risk analysis and resolution.
Security review of a production codebase using an OWASP-based checklist. Covered authentication, input handling, and high-risk flows, with practical remediation recommendations for production hardening.
Store on Magento for a car dealer with subscription support.
Large-scale e-commerce platform for the Swedish market, supporting a wide product catalog, personalized recommendations, and complex pricing logic. Included integrations with payment systems and client-side accounting systems, as well as dynamic content and stock management. Worked on backend development, business logic, and system behavior driven by user activity and purchase patterns. Focused on performance, data processing, and reliable operation of core e-commerce functionality.
Claims management system for an e-commerce platform. Handles returns, item tracking, and claim workflows for order management. Developed as part of a pre-sale process with live coding sessions, leading to successful client acquisition.
Automotive platform with client-facing features and backend workflows. Handled data processing and integration points, and coordinated development of a new version of the online store, supporting operational logic and system interactions.
Web application for displaying schools and related information on an interactive map for Antigua and Barbuda. Included Google Maps integration and an administrative panel for managing locations and data. Handled backend logic and data management for a simple public-facing system.
Web application for interactive data visualization and chart rendering, designed for use in data analysis and moderation workflows. Implemented custom charting using Canvas, along with mobile gesture support and offline capabilities, at a time when such functionality was not commonly available via frameworks. Handled backend logic, data processing, and client-side interaction for dynamic and interactive data presentation.
Content management system for a company website built on Zend Framework. Handles content administration, structured data management, and presentation of company information.
Interactive iPad application for children designed to suggest activities through a randomized selection mechanism. Implements a spinning wheel interface that selects a game or activity, helping children choose what to do next in a playful and engaging way.
Experimental social platform focused on memorial profiles and location-based interaction. Included a mobile application with camera-based functionality to display locations associated with individuals. Developed as a concept project for Open Eye Pictures.
Advertising platform (banner network) for managing campaigns, traffic distribution, and revenue tracking. Handled high traffic volumes, processing data for 10–16M unique hosts per month, requiring efficient data handling and performance optimization. Worked on backend logic, statistics processing, and system behavior under load.
Backend system for a partner program integrated with an auction platform (Zend Framework). Handles partner site management, user registration, content changes, and statistics processing, including integration with external moderation data.
Web platform for game sales and user interaction. Includes e-commerce functionality, user accounts, and discussion features, combining store and social components in a single system.
Backend service acting as a proxy layer for external search engines (Google, Yandex). Processes search queries and responses, enabling controlled access, integration, and request handling.
Telecom systems for cable TV billing, service management, and internal document tracking within a local internet and television provider. Handled subscriber management, service configuration, billing logic, and operational workflows. Developed backend functionality and administrative tools supporting internal processes and service operations in production systems.
Documentation management system for a telecommunications company. Handles centralized storage, search, and structured organization of documents with role-based access and group-level distribution. Includes multilingual interface, administrative tooling, and support for managing large volumes of operational data.
Client management system for a legal company (UK/US). Handles client data, case-related information, and balance calculation based on case activity. Supports centralized management of client records and operational workflows.
E-commerce platform with coupon-based marketing and mobile support. Includes user, product, category, and coupon management, along with SSO authentication across multiple related sites.
These are selected cases, not the full list. Over 18+ years I also worked on internal systems, legacy enterprise products, telecom platforms, integrations, and production support across multiple domains.
CONSULTING
Short engagements.
Senior-level impact.
Focused consulting for architecture, delivery, hiring, and high-risk backend problems.
I work with teams that don't need a full-time hire, but need senior-level support at critical moments. This includes architecture reviews, resolving production issues, stabilizing legacy systems, and supporting hiring and delivery decisions.
When to bring me in:
- before a risky release
- when production issues keep repeating
- when system performance becomes unpredictable
- when architecture decisions are unclear
- when hiring or evaluating senior engineers
- when legacy systems slow the team down
What you get:
- Code review checklist (security, performance, maintainability)
- Architecture review with clear risks, trade-offs, and recommendations
- Identification of bottlenecks and hidden system issues
- Hiring evaluation framework for senior engineers
- Practical, actionable recommendations your team can apply immediately
- Clear next steps for delivery and technical decision-making
how i work
How I work.
Practical, production-first.
I focus on understanding how systems behave in real conditions - under load, under pressure, and over time.
My approach is practical: identify what actually breaks, what slows teams down, and what makes systems harder to evolve - then provide clear, actionable steps to fix it.
- Identify bottlenecks before production
- Validate scaling approach
- Highlight hidden coupling
- Suggest simpler, maintainable alternatives
- Define clear development flow
- Reduce friction between teams
- Align requirements with implementation
- Introduce practical engineering standards
- Architecture decision templates
- Code review checklists
- Delivery guidelines
- Technical standards
- Documentation structure
contact
Let’s build systems that work - not just demos.
Open to consulting, technical leadership, architecture discussions, and interesting engineering problems.
Request a call
Send a message - I’ll get back to you shortly.
Request sent successfully
I'll confirm within 24 hours. If you prefer, you can also use Telegram or the action buttons below.