Contact Us
Customer

A multi-site facilities and pest-control operator managing engineering inspections across large client properties. Field engineers pin site findings blocked drains, structural issues, pest activity to mapped parcels and quadrants, attach photographic evidence, and escalate to the responsible party. PesTrack was built end to end to the client specification and delivered with the complete feature set in place: an interactive Leaflet map with quadrant and parcel layers, findings capture with category, status, escalation, GPS and photographs, construction-zone markers, full PDF report generation, XLSX-driven parcel management, JSON import and export, three-tier role-based access, multi-site tenancy, and immutable audit logging all served from a single Node.js and PostgreSQL deployment.

With the functional scope settled up front, the difficulty of the engagement was not what the application had to do but how it had to behave under real operating conditions. Inspection data compounds each mapped location accumulates repeat visits, and each visit carries multiple high-resolution photographs so a site that is comfortable at launch becomes heavy within months. At the same time several engineers edit the same site concurrently, and the heaviest operation in the product, PDF report generation, runs client-side over the entire dataset including every photograph and map view.

Some of the key blockchain challenges were:
  • Sustained data growth thousands of findings per site, each with repeat visits and attached photographs with map rendering, filtering and list views required to stay responsive as volume climbed.
  • Concurrent modification of the same site by multiple engineers, where one user’s open session could hold a stale view and silently overwrite another user’s work.
  • PDF export as the performance bottleneck: an overall map, four quadrant maps and every finding with its photographs, all composited client-side through html2canvas and jsPDF a naive implementation stalled the browser for minutes on a mature dataset.
  • Photographs moved to remote object storage still had to be fetched, decoded and drawn into reports without repeated network round trips or cross-origin canvas failures.
  • Reports had to represent a consistent point in time even while other engineers were actively writing to the same site during generation.
  • Query performance across a data model that is geospatial, temporal and multi-tenant simultaneously — filtered by site, quadrant, parcel, category, status and date range.
  • An append-only audit trail capturing every write, which grows faster than the findings data it records and must not degrade write throughput.
  • Field-grade connectivity when uploading photographic evidence, with no partial or corrupted saves.
Solutions 
  • Built a layered caching strategy for PDF generation the single largest performance win in the project. Before rendering begins, the client requests a complete report payload in one call, pre-fetches every referenced photograph in parallel, and holds decoded image objects in an in-memory cache keyed by photo reference, so an image appearing in both a quadrant map and a finding detail is fetched and decoded exactly once.
  • Cached rendered map canvas snapshots per quadrant rather than re-rasterising Leaflet tiles for each report section, and reused the base map layer across the overall and quadrant views, reducing html2canvas passes from one per section to one per unique view.
  • Generated each report from an immutable point-in-time dataset snapshot taken server-side at request, so a report remains internally consistent even when other engineers write to the same site mid-generation, and produced pages progressively with released memory between sections to keep the browser responsive throughout.
  • Served photographs via signed, CORS-configured URLs with long-lived CDN cache headers, so repeat report runs and repeat viewers draw from cache rather than object storage, eliminating both the cross-origin canvas tainting problem and redundant network cost.
  • Addressed concurrency with server-authoritative last-write-wins plus per-record versioning: every write carries a server timestamp and record version, stale-version writes are detected and surfaced to the user rather than applied blindly, and open sessions refresh site state so engineers see one another’s changes without reloading.
  • Kept large datasets responsive through viewport-bounded marker loading and clustering on the Leaflet layer, paginated and server-filtered list queries, and composite PostgreSQL indexes on the site, parcel, category, status and visit-date columns that back every filter combination the interface exposes.
  • Separated hot from cold data in the schema findings and current status queried directly, historical visit records and audit entries retrieved on demand, with the append-only audit table written asynchronously so audit volume never blocks a user-facing write.
  • Implemented chunked, resumable photo upload with client-side compression and server-side integrity verification before commit, so a dropped connection in the field never produces a partial record.
  • Enforced tenancy and permissions server-side, mandatory site scoping in the data-access layer, JWT sessions with bcrypt hashing, and a login-time capability manifest driving Admin, Engineer and Client Viewer interfaces from one codebase.
  • Delivered a full administration interface for user and site management including GPS configuration and XLSX parcel upload.
Results
  • PDF report generation over a mature, photo-heavy dataset completes in seconds rather than minutes, with the browser remaining responsive throughout the caching layer removed the product’s single worst bottleneck.
  • Reports are internally consistent regardless of concurrent activity, because each is rendered from a point-in-time snapshot rather than live-read mid-generation.
  • Map and list performance holds steady as findings accumulate, through bounded loading, clustering and indexed server-side filtering rather than client-side processing of the full dataset.
  • Concurrent editing is safe and transparent: writes are attributable and versioned, stale edits are detected and surfaced, and engineers see one another’s changes without manual refresh.
  • Photographic evidence uploads reliably from the field over unstable connections, with no partial or corrupted records.
  • Every create, edit and delete is permanently attributable to a named user, timestamp and IP address, with audit writes decoupled from user-facing latency.
  • Tenancy isolation is structural users see only their assigned sites, and new client properties run on the same deployment with no forked codebase.
  • Administrators onboard sites and manage users entirely through the interface, and the client holds outright ownership of code, data and infrastructure with no dependency on the original development team.
Technologies
  • Node.js, Express.js, RESTful API design
  • PostgreSQL schema design, migrations, indexing, multi-tenant scoping
  • JWT authentication, bcrypt password hashing, role-based access control
  • AWS S3 (object storage for field photographs)
  • Leaflet.js, jsPDF, html2canvas, SheetJS (XLSX) — existing frontend stack
  • AWS hosting, automated HTTPS, daily database backups
  • GitHub client-owned repository, branching and handover workflow
Timeline: 6 Weeks
  • Database schema design, backend API & authentication: 2 week
  • Frontend integration, photo storage migration & role enforcement: 1.5 weeks
  • Admin panel, multi-site management & audit logging: 2 weeks
  • Deployment, domain setup, UAT & handover: 0.5 weeks

Ready to Build Something Amazing?

Get in touch with Prishusoft – your trusted partner for custom software development. Whether you need a powerful web application or a sleek mobile app, our expert team is here to turn your ideas into reality.

image