Automation based on Google Sheets for signing up for trial classes (online language school)

Budget: 12000 UAH Deadline: 7 days

Hello!

I am implementing a web interface on top of Google Sheets so that managers can see the current schedule and work safely at the same time without conflicts.

What I will provide:
• connection to the structure of your sheets via Google Apps Script/API;
• multi-filters by language, request, and teacher;
• calculation of working and free hours;
• 30-minute booking in the interface state;
• automatic weekly updates with the reset of temporary bookings;
• two modes: free slots only / slots + regular classes;
• blocking/control of competitive changes for multiple managers;
• adaptive fast interface and clear conflict messages;
• setup and deployment instructions.

I am a full-stack developer with 4 years of experience in JavaScript, Python, API, databases, and business automation. I will start by checking the prototype and the structure of the actual sheets, create a mapping of fields, and a test scenario for one teacher, and after approval, I will scale it to the entire schedule.

I will deliver the source code and conduct a short walkthrough for the team. I am ready to start immediately. Expand

Budget: 2000 UAH Deadline: 2 days

Good day.
I am ready to take on the order today; I have previous experience in developing LMS.
I propose to implement all server logic on NestJS.
I would be happy to collaborate!

Budget: 4500 UAH Deadline: 3 days

Hello.

I am a NodeJS developer. I have experience with Google Sheets. I am ready to take on the task. Write to me, and we will discuss.

Budget: 13000 UAH Deadline: 5 days

Good day, Ruslana!

Thank you for the clear brief. One point to pay attention to in advance: bookings are only recorded in the interface, without being logged in the Spreadsheet, but correct simultaneous operation of several managers is required. If the booking is kept only in the local state of the browser, another manager simply won't see it and will book a student for the same slot, and upon refreshing the page, the booking will disappear. Therefore, I suggest storing active bookings on the backend (a shared state for all managers), while keeping your Spreadsheet untouched as the sole source of the schedule — just as described in the brief.

The second point — the Google Sheets API has limits on the number of requests per minute. If filters and the calculation of available hours pull data from the Spreadsheet on every click, with several managers simultaneously, this will lead to slowdowns and errors. Therefore, the schedule should be pulled with a single request, cached on the backend, and the filtering and calculation of free/working hours should be done without requests to Google.

What I will do: adapt the existing prototype to the Spreadsheet as the data source, implement multi-selection by language/request/teacher, auto-calculate available hours, book a slot (30 min) with a shared state for all managers, weekly update of the schedule with the reset of old bookings, and two viewing modes.

Stack: React on the front end, Node.js on the backend.

I have experience with integrations with Google Sheets, although previously they were more for marketing purposes (data collection and processing, report automation). Therefore, I understand the specifics of working with the Sheets API and its limitations well, and I am ready to apply this experience here.

Question: how many managers and teachers will be working in the system simultaneously? This affects the caching strategy. Expand

Budget: 5000 UAH Deadline: 5 days

Good day. Ruslana, I can adapt your prototype for Google Sheets so that managers can see the current windows without chaos during simultaneous work. I will create filters by language, request, and teacher, auto-calculation of free/work hours, booking slots only in the interface, and weekly schedule updates with reset of bookings. I have worked with integrations on Laravel/Vue, so I understand the logic of dynamic tables well. I am ready to discuss the details of the specifications and quickly assess the implementation.

Budget: 4500 UAH Deadline: 5 days

Hello, Ruslana!

In this task, the key is not just to connect the ready interface to Google Sheets, but to properly organize the simultaneous work of managers. A booked slot must immediately become unavailable for all users, even if the booking itself is not recorded in the main Sheet.

I will implement: connecting the prototype to Google Sheets, multi-filters by language, request, and teachers, automatic calculation of working and free hours, booking slots for 30 minutes with protection against double booking, two viewing modes, weekly schedule updates, and automatic clearing of bookings from the previous week.

Before starting, I will review the technical specifications, prototype, and examples of sheets, after which I will finalize the data structure and logic of operation. I will also check simultaneous bookings by multiple managers, mobile and desktop versions. Upon completion, I will provide a brief instruction on using and updating the system.

I am currently gathering initial reviews on Freelancehunt, so I am offering a reduced price — 4500 UAH, with a deadline of up to 5 working days after receiving all materials.

Clarification: Should managers log in through their Google accounts or is a separate name/code for the manager sufficient? Expand

Budget: 9000 UAH Deadline: 5 days

The main risk here is double booking while managers are working simultaneously. I will create a shared temporary state with operation locking, weekly resets, and two scheduling modes using Apps Script. On the first day, I will show the field schema and the working scenario for slot conflicts. There is a case similar in logic to pinger.md: a catalog with cards, filters, and a mobile interface. The deadline is 5 days.

Budget: 18000 UAH Deadline: 7 days

Good day, I have over 5 years of experience in development, having worked extensively with web interfaces and integrations in JavaScript and TypeScript.

I created a calculator website for an astrologer: you enter a date and immediately receive a calculation.

I have attached an example, please take a look.

I will adapt the prototype with filters, automatic calculations, and two viewing modes, correctly allowing multiple managers to work simultaneously. I estimate 1-2 weeks until the working version. I will provide the exact cost after a few clarifications or in private messages.

Are there any access requirements for administrators (roles, permissions) or do they all operate in the same mode?

Feel free to reach out! Expand

Budget: 9000 UAH Deadline: 7 days

Hello, I recently created a similar booking platform in the education/services niche (https://siayvo.net/): a schedule with filters by specialist, selection of available slots, role-based access for managers, and an admin panel. The work of several people simultaneously and correct schedule updates were also part of that project.

If you have many teachers with different languages, it’s worth adding highlighting for conflicting slots during parallel bookings right away, as it reduces manager overlaps by about 20%.

Please let me know how many teachers and managers you have at the start, and how often the schedule in the Table is updated, manually every week or on a schedule?

I suggest we get in touch; I will also draft a structure of screens with filters and viewing modes for your prototype, and you can see it live.

Budget: 5000 UAH Deadline: 4 days

I see the task as a neat integration of your prototype with Google Sheets without unnecessary manual actions. I can implement filters by language, request, and teacher, automatic calculation of available hours, booking slots only in the interface, and weekly schedule updates with reset of bookings. I work with PHP/JavaScript and spreadsheets, so I will consider the simultaneous work of several managers. I am ready to discuss the details of the technical specifications.

Budget: 10000 UAH Deadline: 5 days

Good day! Immediately about the contradiction in the requirements, as it affects everything else.

Booking only in the interface and simultaneous work of several managers together does not work: if the booking exists only in the browser, the second manager does not see it and books the same slot. Therefore, the booking needs to be kept in a shared state on the server, not in a Table, as you want, but also not in the browser. Then the slot disappears for everyone at once, and there will be no double bookings.

Second: Google Sheets allows about 60 reads per minute. When several managers are working simultaneously and each action pulls the table, the interface hits the limit and starts to lag. Therefore, I keep the schedule in cache on the application side and update it on a schedule, not on every click.

I tie the booking to the week number, so when pulling a new schedule, they reset themselves without separate clearing logic.

The rest on the list: filters with multi-selection by language, request, and teacher, auto-calculation of free and working hours, two viewing modes. I will adapt the prototype to your specifications and acceptance criteria.

I look forward to collaborating. Expand

Budget: 1000 UAH Deadline: 5 days

Good day!

We have experience in developing web interfaces with **Google Sheets**, implementing booking systems, and multi-user dashboards. We can adapt the existing prototype, implement filters, automatic calculation of teacher availability, booking slots without recording in the table, weekly schedule updates, and ensure proper functionality with simultaneous access by multiple managers.

After reviewing the specifications and the prototype, we will be able to assess the timelines, costs, and propose the optimal technical solution.

Budget: 1000 UAH Deadline: 1 day

Ruslan, good afternoon.

I will make your prototype a working tool: I will connect Google Sheets as the schedule source, add multi-filters, calculate free hours, provide two viewing modes, and enable automatic weekly updates.

An important point: to prevent multiple managers from occupying the same slot, bookings cannot be stored only in the browser. I will create a separate overall booking status — the main table will remain untouched, and managers will immediately see each other's slot occupancy.

I have worked with Laravel, JavaScript, and Google API. Please send the technical specifications, prototype, and an example table — I will quickly assess the volume and suggest an optimal implementation.

Budget: 999 UAH Deadline: 1 day

Good day, Ruslana.

The finished prototype already has a structure — now it needs to be transformed into a working tool where managers can see current slots, filter by language and teacher, and reserve slots without overlapping. I will implement the logic for weekly schedule updates and two viewing modes on top of Google Sheets so that the interface remains fast even with several simultaneous sessions. I am ready to familiarize myself with the technical specifications and examples of tables for an accurate assessment. The provided documents and artifacts will significantly assist in the work and reduce risks and misunderstandings.

Stages:

Each stage is documented, and the code is handed over to you. You can stop after any stage.

≈6 days: 5400–7200 UAH
Creation of a functional interface for displaying and filtering available slots.
- Connection of the interface with Google Sheets to retrieve data
- Basic filters by language and teacher
- View mode for only available slots
- Ability to visually reserve a slot in the interface

≈7 days: 6300–7800 UAH
Full functionality according to the technical specifications, including automation of calculations and support for multi-user mode.
- Full adaptation to your clickable prototype
- Automatic calculation of teachers' working/free hours
- Two viewing modes (available slots / full schedule)
- Weekly data update system and reset of reservations
- Guaranteed stable operation with simultaneous access by several managers

≈7 days: 6300–7800 UAH
Advanced solution with enhanced performance, additional checks, and post-launch support.
- Optimization of data loading speed with large volumes of tables
- Additional data validation to prevent errors in Google Sheets
- Administration guide and support during the first month of operation
- Adaptation of the interface for mobile devices for managers

Required experience:
- https://valpere.github.io/portfolio/
- https://valpere.github.io/projects/
- https://valpere.github.io/mvb/ Expand

Budget: 3000 UAH Deadline: 1 day

🌟 Hello! I am ready to take on your task and provide the necessary technical support. I would be happy to discuss the details of our collaboration and start working.
🏆 Portfolio: Freelancehunt

Budget: 5000 UAH Deadline: 3 days

Hello, Ruslan!

I am Nina from the Valflow IT team. Our frontend developer specializes in creating interactive web interfaces and automating business processes based on JS/TS and Google Sheets API / Google Apps Script.

We are ready to adapt your prototype and implement the booking logic:

1. Integration & Interface Logic:
• Linking the frontend with Google Sheets via Apps Script API / REST API.
• Implementation of multi-filters (language, teacher, request) and 2 display modes (only available slots / slots + regular lessons).
• Automatic calculation of working/available hours and logic for time bookings (30 min) without unnecessary entries in the table.

2. Synchronization & Concurrent Access:
• Weekly automatic schedule updates from the Sheet with correct resetting of time bookings.
• Setting up stable interface operation during concurrent sessions of multiple managers (without data conflicts).

Examples of our projects:
https://valflow.dev/

Execution conditions:
• Cost: 5,000 UAH
• Deadline: 3 days

We are ready to review the technical specifications and prototype for a quick start! Expand

Budget: 777 UAH Deadline: 1 day

Good day.
Our team has many years of experience in developing ERP, CRM, CMS, and specialized software for businesses. We create effective digital solutions that help automate processes, increase productivity, and scale companies.

We work with modern technologies — from bots and scripts to AI agents and analytical systems. We develop websites of varying complexity. In our portfolio, we have implemented ERP solutions for the hotel business, as well as for companies engaged in the import and sale of goods, and our own product XFitness — an ERP system specifically designed for fitness clubs.

We are ready to implement your project and offer the best solution tailored to your needs.
Our portfolio: Freelancehunt

We specialize in the following areas:
- Development of ERP Systems
- Development of CRM Systems
- Development of Websites of any complexity
- Development of CMS Systems
- Support for Websites
- Development of OpenCart
- Support for OpenCart
- Modification of OpenCart
- Refinement of OpenCart
- Development of WordPress
- Support for WordPress
- Modification of WordPress
- Refinement of WordPress
- Development of ECommerce
- Support for ECommerce
- Modification of ECommerce
- Refinement of ECommerce
- Development of Web Applications
- Support for 1C Servers
- Support for Web Servers
- Development of mobile applications
- Data parsing
- Development of bots
- Development of AI agents

and on the following technologies:
- Python
- PHP
- Laravel
- Symfony
- Yii2
- JS
- NodeJS
- jQuery
- TypeScript
- MySQL
- HTML
- CSS
- Vue
- Nuxt.js
- React
- React Native
- C++ Expand

Budget: 5700 UAH Deadline: 4 days

Deadline - 4 days. Budget - 5700 UAH for the working integration of the prototype with Google Sheets and booking logic.

Ruslan, should the booking be shared among all managers, or does each one see only their own time slots? Competitors mention backend and separate storage, but there is a simpler way: a service letter in the Sheet via Apps Script keeps active bookings available for everyone instantly. No extra servers, no limits on requests.

I will pull the schedule with one request once a week, filters and calculation of available hours will work locally. When the week changes, bookings will reset automatically. Managers will not be able to occupy one slot simultaneously. First, I will gather the connection of the prototype with the Sheet on one teacher, you will see it live.

Budget: 6000 UAH Deadline: 5 days

Hello, Ruslana!

I have fully studied your technical specification. The task is clear, plus I have experience in developing educational systems and learning platforms (I have a completed project of a learning system with class logic and interactive modes in my portfolio).

An important architectural nuance: if the booking is only fixed in the browser interface, conflicts and double bookings will arise when several managers are working simultaneously.

How I will implement this correctly:

Data source: Your Google Sheets will remain untouched — the schedule will only be read through the Google Sheets API / Apps Script.

Manager synchronization: Temporary bookings will be implemented through a lightweight state layer (cache/server state). The slot will be instantly blocked for all open tabs of managers without reloading the page.

Filters and calculations: Multi-selection (language, request, teacher), auto-calculation of available 30-minute slots, and 2 viewing modes will work instantly on the client side (React/TypeScript).

Weekly reset: When the week number changes, bookings will be automatically cleared, and a new schedule will be pulled from the Sheet.

📌 I will send a link to my portfolio with the educational project and other works in personal messages (the link is also in my profile on Freelancehunt).

Estimate: 6,000 UAH | 4–5 days.

I am ready to review the technical specification and examples of tables for a quick start! Expand

Budget: 8500 UAH Deadline: 6 days

Good day!

I have reviewed the technical specifications. I can adapt the existing prototype to Google Sheets, implement filtering by language, query, and instructors (multi-select), automatic calculation of available/working hours, two viewing modes, and weekly schedule updates.

I will pay special attention to the correct functioning when multiple managers access it simultaneously. To do this, I will implement a mechanism for temporarily reserving slots without changing data in Google Sheets, to avoid conflicts and double bookings.

I have practical experience working with Google Apps Script, Google Sheets API, JavaScript, and business process automation, so I understand the nuances of working with such solutions.

Before starting work, I will review the prototype and the structure of the tables, agree on the booking logic, and then proceed with the implementation.

Deadline: 6 days.
Cost: 8,500 UAH.

I would be happy to discuss the details and answer any questions. Expand

Budget: 10000 UAH Deadline: 1 day

Hello! This is the perfect task for my stack. I have practical experience in developing web applications with subscription systems, so I understand the specifics of educational projects, schedule management, and time management logic very well.
How I will implement your requirements:
Google Sheets API: I have already worked directly with this API. I will set up correct reading and parsing of data so that the weekly pulling of the new schedule and auto-calculation of hours for teachers works quickly and without unlimited errors from Google.
Synchronization and state (React + Zustand): Since slot bookings are only recorded in the interface, I will use React in conjunction with Zustand for reliable global state management. This is a lightweight, modern, and fast state manager. It ensures that when multiple managers access simultaneously, the filters (language, request, teacher) and time slots will work stably and without conflicts. Switching between view modes will be instantaneous, without unnecessary page reloads.
My works:
artmastermops.net.ua
holydrip.com.ua
my-fitness-club.com
🎁 Bonuses for your project:
Free deployment and hosting for the frontend.
Free connection and setup of your domain.
1 month of free technical support after full launch.
I am ready to review your detailed specifications, clickable prototype, and examples of tables to immediately provide exact timelines and fixed costs for the work. Message me! Expand

Budget: 6000 UAH Deadline: 14 days

Hello! I understand the project: adapting a prototype for Google Sheets with filters, auto-calculation of slots, and two viewing modes.

I have 3.5 years of commercial fullstack development experience in TypeScript, Vue/Nuxt, and NestJS. Among the projects, there are SaaS products with multiple simultaneous users, where it was important to properly organize state synchronization, so I have a good understanding of the issue of concurrent access by several managers.

Regarding the task: pulling the schedule from the table weekly with automatic reset of bookings, multi-selection in filters, and "temporary" booking (only in the interface, without recording in Sheet) is implemented carefully at the component state level tied to the current week. This is a standard but important detail that requires attention during implementation.

I am ready to review your prototype and specifications, assess the scope, and start without unnecessary delays.

Budget: 4500 UAH Deadline: 3 days

I went through the description: filters by language, query, and teacher, auto-calculation of available hours, booking 30-minute slots, and weekly updates from Google Sheets. The logic is clear. Recently, I created a web application for tracking applications using React + Vite with tables, filters, and statuses, so this kind of selection is familiar to me. I also integrated a request form with Google Sheets on the landing page.
Please clarify: should the bookings be shared among all managers? If so, a separate storage will be needed (a second table or a simple backend), because "only in the interface" does not synchronize with multiple users. If local state during the session is sufficient, then it’s simpler.

Budget: 8000 UAH Deadline: 10 days

Good day!

I am interested in your project. I have experience in developing web applications using React / Next.js and working with APIs and integrations. The task of adapting the interface for Google Sheets is also intriguing, especially the part about automatic schedule synchronization, filters, and slot booking.

I am ready to implement the functionality completely: integration with Google Sheets, filtering by language/request/teacher, calculating available hours, booking slots, weekly schedule updates, and two viewing modes.

I initially estimate the implementation at **$600**. I can confirm the exact estimate and timeline after reviewing the technical specifications, prototype, and examples of the sheets.

I am ready to work independently and bring the task to a finished result.

Budget: 1111 UAH Deadline: 1 day

Good day!

I have reviewed the task. I have experience in developing web interfaces using Google Sheets as a data source and automation with Google Apps Script. I have experience in educational projects!

I can implement:

* adaptation of the ready prototype for Google Sheets;
* filtering by language, request, and teacher (multi-select);
* automatic calculation of free and occupied hours;
* booking slots in the web interface without recording in Google Sheets;
* automatic weekly schedule updates with reset of bookings;
* two viewing modes for the schedule;
* correct operation when used simultaneously by multiple managers.

Before starting, I will familiarize myself with the prototype, the technical specifications, and the structure of the tables, after which I will be able to assess the timelines and propose a fixed cost. Expand

Budget: 6000 UAH Deadline: 5 days

Good day!
I am ready to take on this task, I have extensive experience with Google Sheets.

Budget: 12000 UAH Deadline: 10 days

Ruslana, I understand the task: you need to transform a static prototype into a working tool for managers, where Google Sheets serves as a dynamic database with filtering logic for teachers and real-time slot availability. To ensure proper functionality with simultaneous access from multiple managers, it is important to correctly configure request handling through Apps Script to avoid conflicts when writing data and updating schedules. I will set up data exchange between the interface and the sheets so that schedules are pulled automatically, and the interface remains fast even with a large number of teachers. Please tell me how large the database of teachers and students is currently, and if there are specific access rights requirements for different managers?

Budget: 15000 UAH Deadline: 5 days

Hello, I have experience in developing CRMs such as
https://sto.pprintdim.com/demo

Budget: 5000 UAH Deadline: 7 days

I have practical experience in developing web applications and automation based on Google Apps Script, JavaScript, HTML/CSS, and Google Sheets API, so I have a great understanding of the architecture of your project.

Budget: 1000 UAH Deadline: 5 days

Hello!

I have over 7 years of experience in web development. I work with PHP, Laravel, JavaScript, MySQL, APIs, and integrations. I also have experience with Google Sheets API and developing custom web interfaces.

I can implement:

integration of the interface with Google Sheets;
filtering by language, query, and teacher (multi-select);
automatic calculation of occupied and free hours;
booking slots without recording in Google Sheets;
automatic weekly schedule updates with reset of bookings;
two viewing modes;
correct operation when used simultaneously by multiple managers.

For an accurate estimate, I would like to review the technical specifications, prototype, and structure of the Google Sheets.

Approximately:

Timeline: 5–10 working days (depending on details).
Cost: from $400–800 or $20/hour.

Portfolio:

https://programist.pp.ua/ua/portfolio/
https://indexfast.pro
https://devroman.dev Expand

Budget: 4000 UAH Deadline: 3 days

Hello, Ruslan!

I see the key risk of the task — competitive access from several managers given that the booking is not written in the main Table. I am solving this through a separate state layer (cache/service sheet): the schedule is pulled from your working Table with one request and cached, bookings and slot blocking live separately and are updated instantly for all managers — the original Table remains untouched, as required.

What I will do:
— connect the prototype to Google Sheets as the schedule source;
— multi-filters by language, request, teacher;
— automatic calculation of free/work hours;
— booking of 30-minute slots with protection against double booking;
— 2 viewing modes (switching without reloading);
— weekly schedule update with reset of old bookings.

Stack: Apps Script on the backend for reading tables + a separate layer for bookings (to avoid hitting Google Sheets API limits with frequent requests from several managers).

Clarification: how many managers and teachers are expected simultaneously, and how is the transition to a new week in the table determined — manually or by date? Expand

Budget: 27000 UAH Deadline: 20 days

Good afternoon!

For this task, it makes sense to build the solution not as a "direct" interaction with Google Sheets from the interface, but as a web application with a server layer, where the tables remain the source of the schedule, and bookings and manager statuses exist in a separate context. This addresses the main issue of concurrent access: Google Sheets is well-suited for storing schedules but poorly suited for instant synchronization among multiple users without conflicts.

From a technical standpoint, three nodes are important here: the layer for reading the schedule from the tables, the engine for calculating available slots, and the mechanism for temporary locks on slots in the interface. For weekly recalculation, it is better to use week versioning: when the schedule is updated, the system rebuilds the available windows, and local bookings for the old week are automatically reset. This makes behavior predictable and simplifies maintenance.

It is also worth considering that multi-select filters and two display modes will affect not only the UI but also the performance of the query. If the teachers' schedules and regular lessons become a large dataset, it is better to plan for normalization of the structure and caching of free window calculations in advance; otherwise, the interface will start to lag during simultaneous work by managers.

In terms of deadlines, this volume usually fits within 2–4 weeks after reviewing the prototype and current tables. For an accurate estimate, we need to see the structure of the sheets, the rules for forming the week, and the logic by which "working/free" time for the teacher is determined. It is also important to understand whether authorization and rights segregation for managers are required, or if access will be general.

Budget: 18000 UAH Deadline: 14 days

Good day, Ruslana!

The technical specification is clear, but there is one point where such systems usually break down in practice.

You write: bookings are only recorded in the interface, without being saved in the Spreadsheet. But next to it is a requirement for simultaneous work by several managers. These are two mutually exclusive things: if the booking exists only in the browser of one manager, the second does not see it and can easily book a student for the same slot. And upon refreshing the page, the booking will disappear altogether.

I propose a solution that preserves your logic but eliminates this problem: the booking is held on the server and is instantly visible to all managers, while your Spreadsheet with the schedule remains untouched — exactly as you wanted. The weekly reset works as described.

Secondly, it is important to know in advance: Google limits the number of requests to Sheets per minute. If the interface pulls data on every filter click, with three or four managers, there will be lags and errors. Therefore, the schedule is pulled with one request and cached, while the filters and calculation of available hours work instantly, without requests to Google.

What I will do: adapt your prototype, connect the Spreadsheet as the source of the schedule, create a multi-select by language, request, and teacher, auto-calculate available hours, book slots, provide two viewing modes, and ensure correct simultaneous operation of several managers.

Stack: React and TypeScript on the front end, Python (FastAPI) on the back end.

One question: how many teachers and managers will be working in the system simultaneously? This affects how aggressively to cache the data. Expand

Budget: 1000 UAH Deadline: 1 day

Ruslan, good day.

I have repeatedly performed automations with Google Sheets. I have written systems for car service stations, electronics stores, online courses, and others. I can easily implement the requirements you described.

To estimate the cost and timelines, I need more information.

We can discuss the details in private messages. I would be happy to collaborate!

Budget: 7500 UAH Deadline: 3 days

Hello! I am ready to connect the finished layout to Google Sheets as a database with caching, so that filters and slots work without delays. Please send the technical specifications, a link to the prototype, and an example table in private messages — I will assess the scope of work and provide an accurate estimate of time and cost.

Budget: 2000 UAH Deadline: 1 day

Hello! I will do it quickly and reliably! I have created very complex CRMs for Google Sheets. So there will be no problems. Feel free to contact me!

Budget: 4000 UAH Deadline: 5 days

Hello, Ruslan!
Great and clear project! I work with JavaScript / TypeScript and integration of web interfaces with Google Sheets API / Google Apps Script.
I will set up a clear connection between your finished prototype and Google Sheets for quick data loading and updating.
I will implement all necessary filtering (multi-selection by language/teacher), auto-calculation of hours, and a convenient booking grid for 30-minute slots.
I will think through proper data handling so that the interface works without conflicts when multiple managers are working simultaneously.

I am ready to start working immediately after agreeing on the details!

Examples of work:

https://nutri-q-six.vercel.app/ Expand

Budget: 5800 UAH Deadline: 7 days

Hello! I am Serhiy, I have 8 years of experience in IT across various technologies: web/mobile, backend, API, integrations, automation, and data handling.
I see the main task as follows: Automation based on Google Sheets for scheduling trial classes (online language school). What needs to be done: What we will provide: a technical specification with functional requirements and...

Skills for the task:
- task analysis and quick clarification of requirements
- bots, parsing, and data handling
- reporting, analytics, and business automation

Portfolio: https://software.campstudio.net/#showcases

Budget: 5500 UAH Deadline: 5 days

Good day. I have reviewed the logic of the task. The most important point here is the correct simultaneous operation of several managers: after booking, the slot must immediately become unavailable for others, even if the entry itself is not added to the main Google Sheet.

I am implementing the interface based on the ready prototype and Google Apps Script: filters by language, request, and several teachers, automatic calculation of available 30-minute slots, two viewing modes, and synchronization of bookings between managers. To protect against double booking, I will use a shared state storage and operation locking.

The new schedule will be pulled from Google Sheets by week number, and temporary bookings from the previous week will be automatically cleared. Before submission, I will check the scenarios of simultaneous access and functionality on mobile and desktop.

Budget: 3600 UAH Deadline: 3 days

Questions about simultaneous access by multiple managers: the booking slot is not written to the Table, so how is the state synchronized between sessions, through constant polling of the Google Sheets API or is there an intermediate storage (for example, Firebase) for instant status updates of slots in all open tabs of the managers.

Given the technical specifications, I see the task as follows: the Google Sheet remains the source of the teachers' schedule, the interface pulls the timetable once a week and resets local bookings, while filters (language, request, teacher multi-select) and the calculation of available hours are computed on the front end from this data. I will adapt the provided clickable prototype to the actual structure of the tables, creating both viewing modes as a toggle without reloading the page.

After receiving the technical specifications and examples of the tables, approximately 3 days for a working version.

Budget: 6000 UAH Deadline: 3 days

Good afternoon
I would be happy to discuss the details in private messages
--------------------------

Budget: 3000 UAH Deadline: 5 days

Hello, Ruslana! When working simultaneously in Google Sheets, the main risk is locking conflicts when two people book the same slot. I have already automated such processes for online schools, so I know how to set up a request queue without failures.

How do you plan to identify managers when signing up in the interface?

Let's discuss the logic of slot locking during the call.

Budget: 5000 UAH Deadline: 10 days

Ruslan, good afternoon. I understood the task: Google Sheets as a database, with an interface on top of it featuring filters by language/request/teacher, auto-calculation of available hours, and booking a slot for 30 minutes only as a mark in the UI without recording back to the sheet.

The approach is as follows: Apps Script as a layer for reading data from the sheet and publishing via Web App API, the front end takes a ready prototype and is fed with this data. I keep the weekly schedule and bookings in a separate state layer (for example, a separate service sheet or cache) to avoid touching the main working sheets and to prevent conflicts when multiple managers are working simultaneously. Resetting bookings when the week changes and two viewing modes are built into the logic for calculating slots at the backend stage, rather than on the front end, to ensure data is always consistent.

It will take ten days to complete from the moment of receiving the technical specification, prototype, and examples of the sheets.

On a related note: I created a bot for a barbershop that calculates available slots by masters and synchronizes with CRM in real time; the logic is very similar to yours with the calculation of hours by teacher.

Please let me know how many simultaneous managers are expected during peak times and if there are limits on the number of requests to the Google Sheets API that should be considered?