Ömer Akkuş

I designed a backend architecture centered on operational reality, unifying fragmented stock, declaration, and financial processes in bonded warehouse and free storage operations under a single consistent domain model.

At the core of this approach was ensuring lossless synchronization between physical pallet movements in the field and records in the system; I built a deterministic stock model by mathematically normalizing pallet hierarchy, location capacity, and multidimensional measurement distributions.

By integrating handheld terminal and barcode workflows with central services, I placed a digital control mechanism between the point of data generation and the business rules layer; while operational speed increased, I reduced the margin of manual error to a critical minimum.

In high-volume operations, I intentionally stretched ORM boundaries and optimized performance through hybrid data access and server-side processing strategies, while guaranteeing data integrity in multi-step processes with transactional design.

I modeled the dynamic tariff engine as an algorithmic financial layer managing tiered pricing, multiple currencies, and tax scenarios, and established a direct financial accuracy line between stock movements and invoicing.

By digitizing document, declaration, and reporting processes end to end, I transformed the system into not only an operations management tool but also a decision support platform providing financial visibility and auditability.

Technical Contributions and System Design:

▸ Developed performance-oriented data access strategies and query optimizations to support high-volume warehouse operations
▸ Designed the backend business rules layer that ensures data consistency across field operations, stock management, and financial processes
▸ Built a service-based integration structure that manages data flow among terminals, barcode systems, and central systems
▸ Developed server-side processing and efficient data filtering mechanisms for operational screens working on large data sets
▸ Designed control and validation mechanisms that provide fault-tolerant and reliable transaction management in multi-step workflows
▸ Improved the system's decision support capability by developing the reporting and data generation infrastructure that supports operational processes

I designed and developed the Smart Invoice Management and Accounting Automation infrastructure that enables expense invoices to be processed automatically, rule-based, and integrated with operational and accounting systems.

The system analyzes invoices in the background using container numbers, bills of lading, and position information, identifies the correct operational records with a line-item automatic matching algorithm, and automatically posts the invoice without human intervention when a full match is found.

For partial or incorrect matches, I designed a controlled routing flow that transfers responsibility to the relevant operations personnel, and after correction, the system revalidates and completes the process.

Where manual accounting entry for a single invoice previously took an average of 3–5 minutes, with the developed automation, invoices are scanned, associated, and recorded automatically within seconds.

With this transformation, the operational workload in the accounting department was reduced by approximately 95%, manual email traffic and repetitive data entry were eliminated, the risk of error was minimized, and the process became end-to-end traceable, auditable, and scalable.

The system manages high-volume invoice operations efficiently and reliably through a rules engine approach and automatic validation mechanisms.

Technical Contributions and System Design:

▸ Redesigned invoice processing workflows that require asynchronous and high-volume processing using RabbitMQ and .NET Worker Service architecture
▸ Established orchestration between the UI and background services, separating long-running processes from the web layer
▸ Developed the data processing infrastructure that parses Logo-origin e-invoice XML data and relates it to operational and financial domains
▸ Developed a rule-based automatic matching engine that matches invoice lines with operational records
▸ Ensured observability of background processes through Redis-based process tracking and logging mechanisms
▸ Guaranteed data consistency by developing bidirectional finance integration between Logo ERP and the operational system
▸ Designed a system architecture capable of managing high-volume invoice operations in a scalable and high-performance manner
▸ Optimized processes by 95% by reducing manual accounting entry time from minutes to seconds

To eliminate scattered and untraceable request processes at the enterprise scale, I designed a centralized platform that synchronizes bidirectionally with Outlook and directly incorporates emails into the ticket lifecycle.

By continuously monitoring the mailbox through Microsoft Graph, I built an enterprise Request and Task Management Platform that automatically converts incoming emails into ticket records and unifies all service departments, including IT, Finance, HR, and Procurement, on a single backbone.

While Microsoft Graph integration transformed email traffic into an operational workflow, I separated user interactions from I/O-intensive processes through event-driven architecture.

Within this structure that works bidirectionally with Outlook, I completely isolated notification, mail flows, SLA control, and user synchronization from the web request pipeline using RabbitMQ + Worker Service architecture.

I developed an intelligent mail parsing infrastructure that separates email content (HTML body, reply chain, and subject) and processes it either as a new ticket or as a response to an existing ticket.

I designed the security layer that ensures users can access only the requests they are authorized to see through ticket-based access control and role-based authorization mechanisms.

I designed an identity integration structure that validates JWT tokens from the external authentication service and transforms them into the application's internal role and permission model.

I made system behaviors observable and facilitated error analysis and operational tracking with an NLog-based centralized logging infrastructure.

As a result, while I made the ticket lifecycle scalable, operationally observable, and sustainable, I transformed all processes into an end-to-end measurable structure with the Task module, KPI-based reporting, and ERP integration.

Ultimately, all service departments were unified under a single domain, and decision-making and operational visibility became data-driven.

Technical Contributions and System Design:

▸ Automated email → ticket conversion by integrating the mail-based ticket ingestion process with the Microsoft Graph API
▸ Asynchronized mail, notification, and user synchronization processes with RabbitMQ and Worker Service architecture, separating them from the web layer
▸ Increased system scalability by establishing an event-driven communication model between the web application and background services
▸ Optimized high-volume dashboard and reporting queries with Dapper and stored procedure-based data access strategies
▸ Built a centralized cache structure with Redis-based token and session management that improves user experience
▸ Developed a secure and flexible authentication/authorization model by combining JWT validation and cookie-based identity management
▸ Ensured centralized and performant storage of attachments and inline images with FTP-based file management
▸ Separated mail processing, notification, and user synchronization processes by designing worker services as independent tasks
▸ Increased system observability and error traceability through logs written to the database with NLog

I played an active role in transforming the company's Magellan ERP system, where air/land/sea transportation, accounting-finance, CRM, and operations modules ran under a single ASP.NET MVC-based monolithic structure, into a microservice architecture.

By redesigning domain boundaries, I decomposed the system into independent services (Identity, UserManagement, HealthCheck, etc.) and managed inter-service communication through an API Gateway (Ocelot).

I designed authentication and authorization processes under a centralized Identity service with a JWT-based security infrastructure; I developed token generation, claim management, and custom middleware structures.

I improved performance and scalability by using RabbitMQ for asynchronous communication among services and Redis for cache management.

By dynamically selecting the database according to domain and tenant information, I designed a data access structure that supports multi-company and multi-location scenarios.

By abstracting common needs under SharedLibraries (DapperDb, ApiResponse, Logging, Validation, Helper layers), I minimized recurring dependencies and ensured code standardization.

I developed Worker Services for background processing and isolated email sending and verification code workflows from the main request flow.

By structuring each service to run in Docker containers, I established an environment-independent, isolated, and horizontally scalable infrastructure that can be deployed consistently across environments.

I strengthened observability and production error analysis by establishing a centralized logging infrastructure with Serilog and Elasticsearch integration.

I made system dependencies centrally observable with a HealthCheck infrastructure covering SQL Server, Redis, RabbitMQ, and service endpoints.

I improved fault tolerance in inter-service communication through Polly-based retry and resilience policies.

As a result of this transformation, the system was moved to a sustainable architecture that is independently versionable, modular, cloud-ready, and capable of performing under high traffic.

Technical Contributions and System Design:

▸ Redefined service boundaries suitable for microservice architecture by separating the monolithic ERP structure on a domain basis
▸ Provided centralized routing, authentication boundary, and service access control with Ocelot API Gateway
▸ Established a secure inter-service communication infrastructure with JWT-based authentication and a claim-based authorization model
▸ Relaxed inter-service dependencies by establishing an event-driven asynchronous communication model with RabbitMQ
▸ Separated long-running and I/O-intensive processes from the request/response line with the Worker Service structure
▸ Improved performance and user experience by providing distributed cache and session management with Redis
▸ Provided performance-oriented and controllable SQL management with a Dapper-based data access layer
▸ Increased system observability by establishing a centralized logging infrastructure with Serilog and Elasticsearch
▸ Made the live status of system components observable with HealthCheck mechanisms
▸ Built an environment-independent, isolated, and scalable deployment infrastructure by containerizing services with Docker

I designed and developed the backend architecture of a scalable .NET Core MVC-based e-commerce platform that manages dropshipping and e-commerce operations end to end. The system was structured to enable millions of products to be imported into the system in bulk and in sync through supplier API integration, orders to be transmitted automatically to the supplier, and shipment tracking to be managed in real time through cargo integration.

With the Stripe payment infrastructure, I designed a secure payment flow supporting Google Pay, PayPal, and bank cards, and integrated automatic invoice generation and email notification processes after payment. By developing a multi-currency (USD, GBP, EUR) support and a dynamic currency selection mechanism through IP-based location detection, I optimized the global user experience.

In authentication processes, I established a secure and flexible identity verification infrastructure by providing both internal membership and Google OAuth integration. I designed high-traffic operations such as product search, filtering, pagination, category-based listing, and wishlist/cart actions with performance in mind.

While centralizing product, SEO, and order management through the admin panel, I strengthened system observability and error management with an event-based notification system and an NLog-based logging infrastructure. Thanks to this structure, the order processing workflow was automated, the need for operational intervention was minimized, and the platform gained a globally scalable architecture.

I separated the checkout flow from the operational data writing process by asynchronizing order creation with RabbitMQ.

I applied cross-cutting data management strategies such as soft delete, audit fields, and automatic date management to govern the data lifecycle.

I developed the integration layer that manages token lifecycle, error handling, and data synchronization processes in the supplier API integration.

I designed a secure and idempotent order processing flow by separating the post-payment order creation process with webhook validation and queue-based processing.

Technical Contributions and System Design:

▸ Separated business logic from the presentation layer with a layered architecture (Core, Repository, Service, UI)
▸ Made the payment verification process secure and idempotent with Stripe webhook integration
▸ Established an asynchronous order processing pipeline with RabbitMQ, making payment and operational processes loosely coupled
▸ Developed the integration layer that manages product, logistics, order, and tracking processes with CJ Dropshipping API integration
▸ Centralized transaction management in the data access layer with EF Core + Unit of Work approach
▸ Designed admin and customer user management securely and flexibly with ASP.NET Core Identity
▸ Developed a multi-currency and dynamic pricing infrastructure with memory cache and an external currency API
▸ Increased system observability by establishing a SQL-based centralized logging infrastructure with NLog
▸ Developed operational backend processes that centralize order, product, cargo, and content management through the admin panel