
Closed
Posted
Paid on delivery
Build a Replace Unit button for a live power-utility monitoring dashboard. When a field relay is physically swapped out, the replacement serial number must inherit the old unit's location details and its accumulated savings total, so the dashboard continues from where the old relay stopped instead of resetting to zero. Work spans one new DynamoDB table, one new API route, and one React dialog. The system in short The dashboard monitors roughly 372 power-factor-correction relays installed on electricity distribution transformers for a state utility in India. Each relay sits in a panel at a substation and reports over a mobile data SIM to an AWS endpoint every ~70 seconds. One of the dashboard's headline figures is money saved — rupees saved through reduced transmission and distribution losses. That figure is not stored anywhere. It is recalculated on every page load from five cumulative lifetime counters the relay reports: +Ph, -Ph, +Qh, -Qh and CS1h. The counters only ever climb, so the savings figure climbs with them. That is the problem this job solves. When a relay is physically damaged and swapped for a new one, the new unit's counters start at zero. The old unit's entire accumulated savings disappears from the dashboard the moment the serial number changes, and there is no way to recover it. The utility sees the total drop with no explanation. So a replacement needs three things to happen at once: the old relay's savings total is preserved, the new serial inherits the old unit's location and officer details (it is the same physical site — only the serial changes), and the unit page then shows previous savings + current savings = total savings. One detail that makes this tractable: the relay also transmits a daily frame containing those same five counters, and AWS has been storing those daily frames all along. So a relay's end-of-day savings history is already in the database, which is where the preserved figure comes from.
Project ID: 40774630
101 proposals
Remote project
Active 11 hours ago
Set your budget and timeframe
Get paid for your work
Outline your proposal
It's free to sign up and bid on jobs
101 freelancers are bidding on average ₹22,976 INR for this job

Hello, CnEL India can help implement the Replace Unit workflow to preserve accumulated savings and maintain accurate relay records during hardware replacement. **Our Methodology:** 1. **Code & Data Review:** Inspect the existing React dashboard, API structure, DynamoDB schema, daily relay frames, and savings calculation. 2. **Historical Savings Recovery:** Retrieve the old relay’s latest valid daily counters and calculate its preserved savings using the existing calculation logic. 3. **Replacement API:** Develop a secure API route to validate the replacement, preserve historical savings, and associate the new serial number with the existing site and officer details. 4. **DynamoDB Design:** Add the required table with clear relationships between old and replacement units, ensuring historical records remain traceable. 5. **React Dialog:** Build a Replace Unit dialog with input validation, confirmation, and clear success or error messages. 6. **Testing & Verification:** Test duplicate replacements, invalid serial numbers, failed requests, and savings continuity to prevent accidental data loss. We’ll review the existing architecture first and confirm the implementation plan, edge cases, and timeline before development. Best regards, CnEL India
₹25,000 INR in 15 days
8.8
8.8

The project you've outlined for the Replace Unit button is clear, especially that part about needing to maintain accumulated savings when a relay is swapped out. It's critical to make sure that the new unit inherits location and officer details, while preserving the savings total. A common pitfall here is not properly linking the new serial number to the existing data, which could lead to data integrity issues. So, my approach will involve creating a new DynamoDB table to store the necessary details, and I’ll implement an API route that facilitates the data transfer smoothly. I’ll also design a React dialog that allows users to easily initiate the replacement process, just to make sure they don’t lose any accumulated savings. For this, I’ll use the daily frames already stored in AWS to retrieve and display the previous savings accurately. I'm ready to get started on this right away for 22499 INR, let's make sure your dashboard reflects the true savings without any hiccups. Rajavel DynamoDB | API | React | AWS
₹22,499 INR in 10 days
7.4
7.4

Your daily-frame data already exists in AWS, but you have no mechanism to carry forward cumulative savings when a relay serial changes. That means every field swap erases months of reported value with no audit trail. Quick questions - are you currently writing the daily frames to DynamoDB or S3? And do you need the replacement event itself logged for compliance or just the carryover calculation? Here is the architectural approach: - DYNAMODB TABLE: Create a relay_replacements table with composite key (old_serial, replacement_timestamp) storing the five counter snapshots plus calculated savings at swap time. - API ROUTE: Build a POST /relay/replace endpoint that atomically writes the replacement record, updates the location mapping, and returns the preserved savings total for the frontend to display. - REACT DIALOG: Wire a shadcn dialog with Zod validation that accepts old serial, new serial, and swap date, then triggers the API and refreshes the unit page to show previous + current = total. I've built similar carryover logic for a fleet-tracking SaaS where vehicle IDs changed but mileage history had to persist across 12K assets. Let's schedule a 15-minute call to confirm your DynamoDB partition strategy before I start the build.
₹22,500 INR in 7 days
7.2
7.2

As a seasoned software engineer with extensive experience in full-stack web development, I am well-suited for your Power-Utility Dashboard Unit Replacement Button project. With expertise in NextJS, ReactJS, NestJS, and specific proficiency in AWS, I understand the ins and outs of building reliable and user-friendly platforms. Beyond just the coding aspect, my ability to integrate different systems subsequently makes me the perfect fit. Moreover, my skill set extends to proficiently working with HTML, CSS, Javascript, Typescript - languages that are central to creating an intuitive user interface. I believe that software should function brilliantly without compromising on its aesthetic appeal and seamless navigation. My familiarity with digital hosting platforms like AWS would further ensure a smooth deployment of this updated feature. Selecting me for this project means having someone who prioritizes efficient problem-solving while simultaneously keeping technical aesthetics intact. Let's build a matchless power-utility monitoring dashboard together!
₹35,000 INR in 15 days
6.4
6.4

This is a well-bounded problem: preserve the old unit's cumulative savings at swap time, re-point the new serial at the old unit's location/officer metadata, and show previous + current = total on the unit page. Plan: a new DynamoDB table (relay_replacement_history) storing old_serial, new_serial, site/location_id, officer_id, a one-time preserved_savings_total computed from the old unit's last daily frame using your existing formula, timestamp, and performer. A new API route (POST /api/relays/replace) validates both serials, computes that snapshot from the already-stored daily history, writes the record, and updates the new serial with the old unit's location/officer details. A shadcn/Tailwind confirmation dialog on the unit page previews what transfers before committing. Re: your clarification board questions - I'd make replacement non-reversible via UI once confirmed (logged for audit, correctable manually by an admin), and yes to a confirmation step before the dashboard updates. Before starting I'd confirm which existing function computes savings from the five counters, so I reuse it exactly. Timeline: 6 working days - 1 day data model/API, 2 days dialog + integration, 2 days testing edge cases, 1 day buffer.
₹25,000 INR in 6 days
6.8
6.8

Hi, I’d be happy to help you build the Replace Unit feature for your power-utility dashboard. The main challenge is preserving the savings already earned by a relay while ensuring the replacement unit continues reporting its own counters without losing the previous total or creating duplicate savings. I understand that the replacement relay must inherit the old unit’s location and officer details, while its accumulated savings must be recovered from the daily AWS records. The dashboard should then show previous savings plus current savings as the total. I would approach this by adding the required DynamoDB table, API route, and React dialog, with careful handling of the old and new serial numbers. I would also make sure the replacement process preserves the historical savings and avoids accidentally applying the same history twice. Could you clarify how the five daily counters are currently used to calculate savings, and whether the existing backend already has a function for that calculation? I’d be glad to discuss your current AWS structure and agree on a clear implementation plan. Thank you for considering my proposal.
₹125,000 INR in 5 days
5.9
5.9

I’ll implement the Replace Unit workflow so a new relay inherits the old unit’s site and officer details while preserving accumulated savings without resetting the dashboard’s headline figures. My Approach: I’ll add a DynamoDB table to record replacement history and preserved savings, an AWS API route to validate and execute replacements, and a React confirmation dialog. The API will derive the old relay’s final savings from stored daily frames and the existing calculation logic, then link the replacement serial to the same location and officer records. I’ll ensure previous savings + new relay savings = total savings, with safeguards against duplicate replacements, concurrent updates, and accidental data loss. I’ll also add audit logging and tests for counter resets and missing history. 1. Is the backend built with API Gateway/Lambda, and what runtime does it use? 2. Where are daily frames stored, and can I access the existing savings calculation? 3. Should replacement be reversible by an administrator, or permanently recorded? I’ll deliver the DynamoDB schema, API route, React dialog, tests, and deployment notes with careful attention to data integrity.
₹12,500 INR in 7 days
5.9
5.9

The key is to treat a relay swap as a continuity event, not a new installation: preserve the old unit’s last valid savings derived from the daily +Ph, -Ph, +Qh, -Qh and CS1h frame, then attach that baseline to the replacement serial. I’d implement this with one DynamoDB replacement-history table, one API route, and a React “Replace Unit” dialog. My two priorities would be clean implementation and maintainability: the API should validate both serials, capture the preserved savings snapshot once, copy the existing site/officer metadata to the new unit, and store a clear old→new relationship so the operation is auditable and never double-counted. On the unit page, total savings would become: preserved savings from previous unit + live calculated savings from replacement unit That keeps the utility’s headline savings figure continuous while still preserving the new relay’s own raw counters exactly as reported. I’m comfortable working inside live systems where existing data and operational continuity matter more than rewriting architecture. A relevant example is Kingmovers, where we handled live integrations, webhooks, WebSockets, analytics, multiple roles, and production workflows across an existing operational platform.
₹65,000 INR in 7 days
5.8
5.8

**Can start on this today - built live dashboards where totals have to stay right** I am Anand and I can build your Replace Unit flow end to end New DynamoDB table for preserved savings taken from the old units daily frame plus a new API route to swap serial and copy location and officer details and a React dialog to run it The unit page will show previous savings plus current savings as total savings so the headline figure never drops on a swap Recent work: a booking platform still live two years on and a dashboard that replaced an ops teams spreadsheets Want me to start with the table and API route first?
₹23,700 INR in 7 days
5.3
5.3

Hello, The figure to preserve isn't a total, it's a snapshot — and that's the decision this job hinges on. If you store the old relay's final savings number as a single value, you lose the ability to audit it later or explain it to the utility. Better to store the five cumulative counters from the last daily frame plus the computed savings at replacement time, so the preserved figure can be recomputed and traced. So: a replacements table keyed by old serial → new serial with location, officer, counters, computed savings and timestamp. One API route that writes it transactionally and reassigns the location record. One React dialog in shadcn/ui that confirms the swap and shows the inherited figure before commit. The unit page then renders previous + current, with previous reading from that record rather than a hardcoded sum. Two things I need before starting: what's the daily-frame schema in DynamoDB, and is the location→serial relationship a single record that gets reassigned, or does the relay embed location in its frames? Are location details stored on the relay record or the panel record? Looking forward to working with you. Ankit
₹25,000 INR in 7 days
4.8
4.8

Handling 70-second telemetry and monotonic counters (+Ph, -Ph, +Qh, -Qh, CS1h) requires an explicit baseline offset so the state utility never sees rupee totals drop during relay swaps. I will implement the complete replacement workflow across DynamoDB, your API, and the React frontend. Execution plan: ✅ DynamoDB Lineage Schema: Create a dedicated table storing serial transitions, transformer site IDs, officer assignments, and preserved baseline savings extracted from the old unit daily frame. ✅ Replacement API Route: Implement a typed endpoint that validates the new serial, rebinds site metadata, locks in historical accumulated rupees, and commits the replacement atomically. ✅ React Dialog: Build a clean shadcn/ui replacement modal in Vite/Tailwind with input validation, swap confirmation, and immediate state updates. ✅ Savings Aggregator Patch: Update the UI calculation logic so total money saved accurately computes as inherited baseline savings plus live counter savings. Does the API need to compute intra-day savings up to the final 70-second frame, or is anchoring strictly to the last stored daily frame sufficient?
₹20,000 INR in 1 day
4.6
4.6

Hi, Before, I built dashboard features that preserved historical device data when hardware or identifiers changed. - The main challenge was linking a new device serial to the old unit’s history without corrupting live readings. - I created a replacement record, copied site and ownership details, and combined historical and current metrics. - The dashboard then displayed a continuous total while keeping a clear audit trail of the swap. For your power-utility dashboard, the key factors are accurate savings preservation, clear unit lineage, and safe DynamoDB updates. - First, I will review the existing data model, daily counter frames, API structure, and React components. - Then, I will create a replacement table storing old serial, new serial, swap date, officer, location, and preserved savings. - The new API route will validate the swap, inherit site details, and calculate the old unit’s final savings from its last daily frame. - The React dialog will guide the user through old serial, new serial, date, and confirmation before saving. - The unit page will show previous savings, current savings, and total savings, with a full replacement history. Q1: Can you share the current DynamoDB table schemas and an example daily counter frame? Q2: Should the replacement date be entered manually or detected automatically from the first reading of the new serial? Looking forward to your reply.
₹25,000 INR in 5 days
4.6
4.6

Hi, I can implement the Replace Unit feature using React, TypeScript, and AWS DynamoDB. I’ll build the API and replacement dialog to preserve historical savings, transfer location and officer details, and calculate total savings correctly without resetting the existing records. I’ll also handle validation, error cases, and testing to ensure the replacement process is reliable. I’m available for an instant call to discuss your current architecture and requirements.
₹12,500 INR in 7 days
4.2
4.2

Hello, this is a well-scoped change and I like that it touches one table, one route and one dialog. The key design point is to treat a replacement as an event, not as an edit of the old unit: a new DynamoDB item records old serial, new serial, timestamp and the savings total carried over, and the dashboard reads the cumulative savings as the old unit's final total plus everything the new relay reports after the swap. That keeps the history auditable and lets you answer later which relay produced which savings. The API route would validate that the new serial is not already active, write the replacement record and update the location mapping in a single DynamoDB transaction, so a failure halfway can never leave two units claiming the same location or a total counted twice, and the route would be idempotent if the operator clicks twice. The React dialog would confirm the old unit, the new serial and the carried-over figure before saving. I work daily with AWS, serverless APIs and React as the architect of a payments platform, where carrying balances correctly is the core problem. Which stack serves the API: Lambda behind API Gateway or a container? I can deliver in 7 days. Regards, Braiam
₹20,000 INR in 7 days
3.8
3.8

Hello, As the Indian saying goes, “Where there is a will, there is a way.” As this word means, in this project the important part is just preserving the utility’s real savings history while making the replacement relay feel like the same site. I would build the DynamoDB replacement record, API route, and React dialog so the old relay’s accumulated savings is calculated from its stored daily frames, while location and officer details transfer to the new serial. The unit page would then clearly combine previous savings with the new relay’s current savings instead of resetting the total. The flow will include validation around the old and new serial numbers, prevent accidental replacement records, and keep the existing dashboard behavior intact. Would you like the replacement action to require confirmation showing the calculated preserved savings and the old/new serial numbers before it is committed? Best regards, Michel
₹15,000 INR in 4 days
3.1
3.1

Hi, The critical part of this replacement workflow is preserving the old relay's accumulated savings without resetting the dashboard total or counting historical savings twice. I'd first trace the existing savings calculation and daily-frame storage to identify the correct end-of-day counters and reproduce the current calculation accurately. I'd then implement the DynamoDB table for replacement history, an API route to validate the old and new serials and transfer the site's location and officer details, and a React Replace Unit dialog. The workflow would preserve the old unit's savings separately from the replacement unit's live savings, ensuring the displayed total remains previous savings plus current savings. I'd also account for retries, duplicate submissions, missing daily frames, and validation errors to prevent incorrect totals or accidental replacements. I'd test the replacement flow against existing records and verify that normal relay updates continue working correctly. Best regards, Deepak.
₹12,500 INR in 7 days
2.8
2.8

Hi Deepanshu, I will build the Replace Unit React dialog, API route, and DynamoDB table so new relay serials inherit location details and carry over preserved savings seamlessly. I can deliver this complete within 3 days for 20,000 INR. I can start immediately.
₹25,000 INR in 3 days
2.4
2.4

Extracting the end-of-day history from DynamoDB and passing it into a React dialog for the serial number swap is the cleanest way to preserve that accumulated savings total without resetting the utility metrics. I will build the new API route to query the daily frames for the old serial number, create the DynamoDB table to map the relay replacement event, and hook it up to the frontend UI. The new serial will inherit the previous location details and feed the calculation so the lifetime counters display continuously from the exact point of the swap. Can we query the existing daily frames directly by the old serial number in DynamoDB, or should we store a pointer to the last recorded daily counter value in the new replacement table during the button action?
₹27,500 INR in 7 days
2.6
2.6

Adding that Replace Unit button for your field relays sounds straightforward. Do you already have the API endpoints ready for when the button triggers, or should we map those out first?
₹22,500 INR in 7 days
2.5
2.5

Hi, this is a nicely scoped job and I like how clearly you've described the counter problem. Here's how I'd implement it, so you can judge whether I've understood it: 1. DynamoDB: new table `unit_replacements` keyed by site/location id, storing old_serial, new_serial, replaced_at, the old unit's officer/location details, and a frozen `previous_savings` snapshot computed from the last stored daily frame of the old serial (the five counters +Ph, -Ph, +Qh, -Qh, CS1h run through the same savings formula the dashboard already uses). Replacement chains (a unit replaced twice) are handled by summing the chain. 2. API route: POST /units/:serial/replace - validates the new serial exists and isn't already assigned, writes the replacement record in a transaction, copies location + officer details onto the new serial, and returns the preserved total. Idempotent, with an audit entry. 3. React dialog (Vite + TypeScript + Tailwind + shadcn/ui): "Replace Unit" button on the unit page, dialog with new serial input, lookup/validation, a confirmation showing what will be inherited, then the unit page shows previous savings + current savings = total savings, plus a small replacement-history note. Background: 10+ years React/TypeScript and Node, AWS (DynamoDB, Lambda, API Gateway) in production, and I've built monitoring dashboards fed by IoT telemetry before. ₹25,000, 7 days including your review. Can start right away.
₹25,000 INR in 7 days
2.5
2.5

Delhi, India
Member since Dec 9, 2025
₹150000-250000 INR
₹37500-75000 INR
₹75000-150000 INR
₹12500-37500 INR
₹600-601 INR
$30-250 AUD
₹600-1500 INR
$250-750 USD
₹10000 INR
$250-750 USD
$250-750 USD
$15-25 USD / hour
₹1500-12500 INR
₹15000-30000 INR
$250-750 CAD
$250-750 USD
$30-250 USD
$750-1500 USD
$2-8 USD / hour
$250-750 USD
$58 CAD
₹12500-37500 INR
$15-25 USD / hour
£250-750 GBP