Development of a .NET microservice for processing and synchronizing Excel data

Budget: 27000 UAH Deadline: 20 days

> Deadline - 20 working days, budget - 120,000 UAH for a working microservice with gRPC, XLSX processing, saving to PostgreSQL via EF Core, basic tests, and preparation for container launch.

> We are ready to work with your gRPC contracts. For .NET microservices, we usually divide the application into a contract layer, application commands and queries, business logic, infrastructure, and tests. We assemble DI through separate dependency registration modules so that the Excel parser, validation, processing queue, repositories, and execution status do not mix into one combine. Here’s the nuance - for large files, it’s more important not just to read XLSX, but to avoid memory overload and correctly manage the processing status =)

> For Excel in .NET, we worked with streaming processing, type validation, mapping to business models, and importing into the database. We will choose the library after assessing the actual file sizes - EPPlus is convenient, OpenXML is often better where resources and reading control are important.

> Questions for accurate assessment
>> Are there already approved .proto files and PostgreSQL table schema?
>> What are the maximum file sizes - number of rows, sheets, file weight, and expected processing parallelism?

> Relevant examples
>> https://business.ingello.com/platforma - corporate platform with modular architecture and complex server part
>> https://business.ingello.com/forma-bpm - automation of business processes, statuses, roles, and reliable operation processing
>> https://business.ingello.com/iks - closely related to accounting systems and data synchronization

> About Ingello Systems on Freelancehunt - https://systems-fl.ingello.com

> It feels like the project is better done not as a one-time import, but as a careful data processing service. A penny-wise man pays twice - especially when Excel suddenly becomes a production integration, not just a file on the desk. We check critical nodes with tests and leave the code suitable for extension. Expand

Budget: 12000 UAH Deadline: 7 days

Good day!

I am interested in your task. I have strong experience in backend development on .NET (including .NET 8/10) and a solid understanding of the challenges of streaming large data.

Briefly on your requirements:

Microservices: I build isolated, fault-tolerant services with deployment in Docker.
Modularity and DI: I use Clean Architecture. I register dependencies through the standard MS DI container at the level of each module. For CQRS, I use MediatR, which allows me to keep the gRPC layer clean. For EF Core, I apply the Repository and Unit of Work patterns.
Working with Excel: For large files, I do not use the popular EPPlus to avoid OutOfMemoryException (it loads the entire DOM model into memory). My choice is ExcelDataReader for fast forward-only streaming reading. To save tens of thousands of rows in PostgreSQL, I use batch inserts (Bulk Insert / SQL COPY) to avoid overloading the DBMS.
gRPC: I have experience designing .proto contracts. I understand the specifics of transferring large files (I will apply Client Streaming stream bytes to read the file in chunks on the fly).
I guarantee clean SOLID code, unit test coverage for the parser and mappers (xUnit + Moq), and a fully configured Dockerfile.

I would be happy to discuss the details in a short call or perform a test! Expand

Budget: 20000 UAH Deadline: 15 days

Good day, I can help with the implementation of a microservice on the .NET stack, write for further discussion.

Budget: 12000 UAH Deadline: 3 days

Hello. I reviewed the task, the stack is completely my area. Let me go through your requirements:

I regularly write microservices in .NET, and I have no issues with context isolation and packaging in Docker. For architecture, I prefer Clean Architecture: I configure DI strictly by layers, isolating business logic through CQRS (usually using MediatR). With this approach, everything scales easily and is covered by unit tests without problems.

I have worked a lot with parsing large XLSX files. The main issue here is not to run into OutOfMemory. I know EPPlus very well, but if the files are going to be hardcore, it's better to read them in a stream (for example, using ExcelDataReader) to ensure the service runs stably and doesn't consume too much memory.

I am ready for gRPC and .proto contracts, often using them for inter-service communication. Writing to Postgres through EF Core will be done carefully through Repository / Unit of Work, ensuring thread safety.

If everything is okay, I am ready to review the contracts and discuss technical details.

Budget: 25000 UAH Deadline: 14 days

An isolated .NET service is needed that accepts Excel files, validates them, and transforms them into PostgreSQL without breaking other parts of the system.

I will build it this way: gRPC contract via .proto with Submit/GetStatus methods, command processing through MediatR (CQRS), each handler is isolated and testable. For parsing XLSX, I will use ClosedXML or ExcelDataReader — they read line by line through IEnumerable without loading the entire file into memory, which is critical for large tables. Data layer: Repository + Unit of Work on top of EF Core, transactions at the batch row level, so partial failures do not leave garbage in the database. Thread safety through Channel or SemaphoreSlim at the worker level if parallel processing of multiple files is needed.

What is the typical file size and expected peak load — how many files per unit of time should the service handle?

Budget: 10000 UAH Deadline: 7 days

Good day! I have reviewed the task — the stack is familiar, and I can implement it. I will develop a microservice on .NET 10 with gRPC API, XLSX parsing using EPPlus, and Repository/Unit of Work over PostgreSQL via EF Core. CQRS and DI are standard approaches in my projects, with a modular architecture allowing for scalability. I will ensure thread safety when processing large files through an async pipeline with memory management.

Budget: 27000 UAH Deadline: 22 days

We already have a practically ready similar solution for processing Excel and queues, which can be quickly adapted to your gRPC contract. We can discuss the details right here; I'm available.
For the timeline, I would estimate 18-24 working days for the service with an API, a parser for large XLSX files, validation, writing to PostgreSQL via EF Core, containerization, and basic tests.
Regarding the budget, the initial estimate is 90,000 UAH, but it depends on the number of Excel templates and validation rules.
We can work strictly according to gRPC contracts, document .proto, and usually organize DI by modules - Application, Infrastructure, Persistence, Worker, Contracts.
For Excel, we used EPPlus and OpenXML; for large files, we perform streaming reading, batch processing, memory limitations, and idempotent task statuses.
It seems the main risk here is not reading Excel but normalizing rules and ensuring repeatability of results with large files.
At the start, we will go through 2-3 real files to avoid establishing false rules in the parser.
As for clarifications, how many different XLSX formats need to be supported, and are there already approved .proto and PostgreSQL schema?
For similar corporate systems, you can check https://business.ingello.com/platforma, where the logic of a reliable platform with modules and integrations is close.
Also, https://business.ingello.com/forma-bpm, where process automation and business data processing are similar.
Our FLH landing page on systems and AI automation is https://systems-fl.ingello.com. Expand

Budget: 21000 UAH Deadline: 14 days

Maxime, I see that you need a reliable service for processing Excel files that automates complex manual data work and ensures their correct integration into your microservices system.

I will develop a microservice with a gRPC API that will efficiently accept large Excel files, perform validation and transformation according to your rules. The result will be a structured and cleaned representation of data in PostgreSQL, ready for further use, which will eliminate errors and speed up data processing.

Are there already prepared examples of Excel files or clear business rules for their parsing and validation?

Budget: 25000 UAH Deadline: 30 days

Hello!

I have reviewed your task — I am familiar with this architectural approach. I have experience building modular systems on .NET, so I am ready to implement a reliable service for processing Excel data according to your requirements for architecture and performance.

My experience and approach to implementation:

Microservices and architecture: In my projects, I strictly adhere to SOLID principles. To organize modularity, I use the CQRS pattern (via MediatR), which allows for a clear separation of commands for writing and reading data.

Dependency Injection (DI): I build a DI container using pure Microsoft.Extensions.DependencyInjection, grouping service registrations by modules (via extension methods of IServiceCollection), which makes the system easy to scale.

Working with Excel: I have experience with EPPlus (if the license allows) or OpenXML (for working with large files in streaming mode using OpenXmlReader, which minimizes RAM consumption).

gRPC and contracts: I have experience with gRPC services, so I am ready to strictly adhere to .proto contracts and efficiently handle execution statuses.

Resource efficiency: When processing large XLSX files, I use a Stream approach to avoid loading the entire file into memory and process data in chunks (chunk processing).

I would appreciate any additional questions:

Do you already have defined domains for modeling, or will they need to be developed from scratch based on the provided specifications?

Is there a plan to use a message broker (e.g., RabbitMQ) for asynchronous processing, or should gRPC be called synchronously?

I am ready to demonstrate examples of code organization where similar patterns are used. I would be happy to discuss the details! Expand

Budget: 18000 UAH Deadline: 31 days

Hello. I am a .NET developer focused on high-performance microservice architecture. My stack includes C#, .NET, gRPC, PostgreSQL, and EF Core. I have experience building modular applications using CQRS, Repository, and Unit of Work patterns.

Responses to your requirements:

Experience with .NET in microservices:
I develop backend microservices that interact exclusively via gRPC. I can design distributed systems ensuring data consistency.

DI and modularity:
I build projects on a modular principle, encapsulating domain logic. I actively use Dependency Injection and primary constructors at the class level. My approach ensures loose coupling of components, simplifying scaling and writing tests.

Working with Excel:
I have experience processing large datasets. For parsing XLSX, I prefer OpenXML or EPPlus, depending on performance requirements. I can implement streaming file processing to minimize memory consumption when working with large documents.

Working with gRPC:
I work strictly through gRPC contracts. I have experience designing .proto schemas, managing streaming data exchange, and implementing fault-tolerant error handling at the service level.

I am ready to start working on the task soon.

Question for clarification: Do I need to prepare a .proto file template or project structure for this project to attach them to the response for clarity? Expand