From Drone to Done
RoofLens is a SaaS platform that converts drone and aerial photos into precise roof measurements, damage maps, and automated line-item estimates. Built for small-to-mid-size roofing contractors and insurance adjusters, it eliminates manual measuring and spreadsheet guesswork to produce ready-to-send PDF bids in under an hour, cutting estimating time up to 70% and reducing disputes.
Subscribe to get amazing product ideas like this one delivered daily to your inbox!
Explore this AI-generated product idea in detail. Each aspect has been thoughtfully created to inspire your next venture.
Detailed profiles of the target users who would benefit most from this product.
- 29–42, residential roofing sales rep at a growing, mid-size contractor. - Works storm‑prone suburbs; 200+ miles weekly; 5–7 in‑home appointments daily. - 3–7 years selling exterior trades; tech‑comfortable; iPad and CRM heavy. - Compensation: base plus commission; accelerators for same‑day signatures and upsells.
Started as a canvasser, losing deals while waiting on takeoffs. Adopted tablets and drones after faster competitors kept beating him. Now aims to leave every driveway with a signed, defensible bid.
1. Instant preliminary estimate from minimal photos. 2. Homeowner‑friendly visuals to explain scope. 3. Pay‑per‑job pricing for variable volume.
1. Waiting days for takeoffs kills momentum. 2. Inconsistent measurements trigger awkward callbacks. 3. Evening follow‑ups buried in paperwork chaos.
- Burns for same‑day signatures and referrals. - Trusts visuals more than roofing jargon. - Impatient with back‑office delays and rework. - Competitive, tracks close‑rate like a sport.
1. YouTube sales tips 2. Facebook Groups roofing pros 3. Google Search local estimates 4. LinkedIn industry peers 5. Apple Podcasts sales coaching
- 35–50, Operations Director at a 5–12‑location roofing franchise. - Manages 20–60 estimators and reps; multi‑state compliance responsibility. - Bachelor’s in business/CM; KPI‑ and SOP‑driven; spreadsheet native. - Budget owner for tooling; accountable for margin, cycle time, quality.
Rose from senior estimator to ops after inconsistent bids hurt margins and brand. Built SOPs but fights tool sprawl and shadow processes. Seeks one enforceable estimating system.
1. Role‑based templates with locked line items. 2. Central approvals, SLAs, and exception alerts. 3. Team analytics by branch and rep.
1. Rogue estimates erode margins and trust. 2. Manual roll‑ups waste reporting hours weekly. 3. Disconnected tools confuse and slow teams.
- Obsessed with playbooks and consistent execution. - Data‑first; dashboards before gut instincts. - Risk‑averse on compliance and brand reputation. - Empowers teams, demands measurable accountability.
1. LinkedIn industry ops 2. YouTube admin tutorials 3. Google Search SOP templates 4. Slack communities operations 5. Email newsletters roofing
- 32–55, commercial estimator at a regional roofing contractor. - Handles 5–10 bids weekly; roofs 40,000–200,000 sq ft. - Proficient in Bluebeam/CAD; collaborates with GCs and architects. - Office‑based with regional site walks for verification.
Started as an architectural drafter before moving into estimating. Lost nights redlining prints when measurements didn’t match as‑builts. Now insists on traceable geometry and exportable layers.
1. Parapet, wall, and penetration counts labeled. 2. DXF/DWG exports at exact scale. 3. Adjustable tolerances per specification.
1. Aerial shadows obscure boundaries and edges. 2. Manual digitizing consumes late nights. 3. Scope misreads force costly change orders.
- Precision over speed; hates ambiguous edges. - Collaboration‑minded with architects and subs. - Documentation‑heavy; everything must be traceable. - Cautious about assumptions and tolerances.
1. Bluebeam Forum workflows 2. LinkedIn commercial estimators 3. YouTube CAD tips 4. Google Search spec sheets 5. Reddit r/Construction
- 35–60, licensed public adjuster; works multi‑state CAT deployments. - Manages 8–20 active claims; contingency‑fee compensation. - Travels frequently; home office evenings for documentation. - Experienced with Xactimate; comfortable with drone/aerial imagery.
Former roofing PM turned public adjuster after repeated scope disputes. Built a reputation for airtight files that survive carrier audits. Needs evidence that stands up in escalations.
1. Carrier‑aligned line items and codes. 2. Timestamped damage maps with notes. 3. Shareable audit trails for escalations.
1. Carrier pushback on scope definitions. 2. Disorganized photos derail negotiations. 3. Inconsistent third‑party reports undermine cases.
- Justice‑minded, fights for policyholder fairness. - Evidence over emotion; meticulous documentation. - Tenacious follow‑ups until resolution. - Prefers tidy, timestamped paper trails.
1. LinkedIn public adjusters 2. Facebook Groups PA forums 3. X (Twitter) CAT updates 4. YouTube case studies 5. Email newsletters insurance
- 28–45, QA/compliance lead at a mid‑size roofing company. - Reviews 20–40 projects daily across multiple branches. - Former crew lead; OSHA‑minded; checklist expert. - Office‑based; coordinates constantly with field and desk teams.
Moved from crew lead to QA after warranty claims exposed sloppy documentation. Built internal checklists but needs automated coverage verification and approval control.
1. Automated coverage checks and quality flags. 2. Locked templates with approval gates. 3. Exception reports by user and branch.
1. Missed photos trigger expensive re‑flights. 2. Template drift causes inconsistent bids. 3. Version confusion multiplies rework.
- Detail‑obsessed; zero tolerance for sloppiness. - Risk‑averse; prioritizes compliance and safety. - Coach mindset; prefers teachable moments. - Loves clear standards and exceptions.
1. YouTube QA workflows 2. LinkedIn roofing ops 3. Google Search checklists 4. Slack communities quality 5. Email policy updates
- 34–52, manages 50–200 roofs for REITs or schools. - Budget owner; accountable to CFO, boards, and tenants. - Facilities background; now a data‑centric portfolio manager. - HQ office‑based; site visits monthly or after storms.
Started as a facilities tech, promoted after taming reactive maintenance chaos. Burned by opaque vendor bids and surprise failures, now demands comparable scopes and clear ROI forecasts.
1. Portfolio rollups with standardized condition grades. 2. Apples‑to‑apples bid comparisons. 3. Maintenance planning exports for boards.
1. Incomparable estimates stall approvals. 2. Surprise leaks disrupt operations. 3. Site access delays slow surveys.
- Budget‑disciplined; hates surprise costs. - Prefers dashboards over trade jargon. - Risk‑averse; prioritizes tenant uptime. - Vendor‑neutral, outcome‑focused decisions.
1. LinkedIn facility management 2. IFMA forums discussions 3. Google Search vendor comparisons 4. YouTube maintenance planning 5. Email CRE newsletters
Key capabilities that make this product valuable to its target users.
Distributes triaged jobs across estimators and drone operators using live capacity, time windows, and skill tags (steep, tile, commercial). Prevents overload, keeps queues moving, and raises same‑day completion rates without manual juggling.
Maintain real-time capacity for estimators and drone operators by factoring shift schedules, PTO, active and queued workload, travel buffers, and per-day caps. Incorporate job duration models derived from historical averages by roof type, pitch, and complexity. Represent capacity in normalized units with current and forecasted availability per time window. Integrate with user profiles, calendar feeds, and the triage pipeline so capacity automatically updates on assignment, completion, or schedule changes. Expose query and subscription APIs for the balancer to retrieve snapshots and react to capacity changes.
Ensure only eligible resources are considered for assignment by enforcing skill tags (e.g., steep, tile, commercial), certifications, and required equipment. Provide admin configuration for tags and defaults per job template, with automatic tag inference from RoofLens triage metadata. Block or warn on overrides that violate compliance, require approval where configured, and log reasons when jobs are unassignable due to missing skills. Surface suggested eligible resources and nearest alternatives.
Honor customer time windows, promised SLAs (e.g., same-day), and blackout periods when scheduling. Score candidates by ability to satisfy the earliest feasible window, prioritizing same-day completion. Account for operator travel time via mapping APIs and buffer for upload/processing stages. Reserve capacity for urgent jobs, highlight SLA risk, and visualize assigned windows on shared calendars. Detect and flag conflicts prior to confirmation.
Distribute triaged jobs using configurable strategies (least-loaded, round-robin within region, proximity for drone ops) weighted by skill match, capacity fit, time window feasibility, and SLA urgency. Support streaming and batch assignment as jobs arrive. Include deterministic tie-breakers and fairness over time, and enforce business rules (e.g., max concurrent inspections, per-day estimate limits). Produce assignment decisions with confidence scores and rationale, persist results, and update capacity accordingly.
Provide UI and APIs for authorized users to override, lock, or reassign jobs with real-time conflict checks. Warn on violations of skills, capacity, and SLA constraints, and require justification where policy dictates. Capture a complete audit trail (who, when, why, previous and new assignee, rule inputs) and support bulk rebalancing during outages or weather holds with undo capability. Prevent double-booking and maintain historical assignment lineage.
Send real-time notifications to assignees with job details, scheduled window, location, and required skills via mobile/app/email. Allow assignees to accept or decline within a configurable response window; on decline or timeout, automatically reassign to the next best candidate per balancer rules. Sync accepted jobs to personal calendars and record acknowledgments for SLA verification. Provide throttling and quiet hours to avoid notification fatigue.
Detect unassignable jobs (no eligible resource, capacity exhausted, weather holds), scheduling conflicts, and SLA-at-risk items. Route them to an exceptions queue with reason codes, recommended actions (relax constraints, extend windows, engage subcontractors, split tasks), and prioritization. Trigger escalations to managers via alerts and webhooks, and track resolution status and time-to-clear for operational reporting.
Shows a per-address probability of meeting the due time based on queue length, route ETA, daylight, and weather. Flags at‑risk jobs early and recommends actions (reassign, bundle, rush) to protect SLAs and customer promises.
Compute a per-address probability of meeting the due time by combining queue length, live route ETA, daylight windows (sunrise/sunset and civil twilight), and granular weather forecasts (precipitation, wind, temperature) with historical job durations by roof type, pitch, and crew performance. The engine produces a calibrated probability (0–1), confidence band, and risk tier, updating automatically when any input changes. It is timezone-aware, resilient to missing data via priors and fallbacks, and persists predictions with timestamps for traceability. Exposes internal thresholds for flagging, supports batch scoring for daily schedules, and meets performance targets (<200 ms per job, horizontal scaling). Integrates with RoofLens scheduling and job objects via service-to-service APIs.
Establish secure, monitored integrations for all predictor inputs: routing ETA (existing dispatch/route service), queue length (job pipeline), weather (hourly/nowcast by lat/long), and daylight (sunrise/sunset calculations). Includes geocoding addresses to coordinates, timezone resolution, caching and refresh schedules, retries with exponential backoff, rate limiting, and fallbacks when upstreams degrade. Normalize units and schemas, validate payloads, and store a local, short-lived cache to reduce latency/cost. Manage credentials via secrets storage and provide observability (health checks, metrics, alerts) to ensure continuous, accurate data flow into the SLA Predictor.
Automatically flag jobs whose predicted on-time probability drops below configurable thresholds or whose daylight or weather constraints imply likely breaches. Display risk badges in lists and job detail views, and emit real-time alerts through in-app notifications, email/SMS, and webhooks. Support organization- and job-type-specific thresholds, deduplication and cooldown windows, escalation rules, snooze/acknowledge actions, and audit of alert lifecycle. Enable bulk views and filters for "At Risk Today/This Week" to streamline daily standups and route reviews.
Generate ranked mitigation options when a job is at risk, such as reassigning to a nearer crew, bundling with nearby stops, adjusting sequence, or marking for rush. For each recommendation, estimate uplift to on-time probability, expected cost/impact, and spillover effects on other jobs. Provide one-click actions or deep links to dispatch tools, plus sandboxed "what-if" simulations to compare scenarios before committing. Respect operational constraints (crew skills, capacity, service hours, daylight, weather windows) and explain assumptions used in each recommendation.
Surface clear reason codes and top contributing factors (e.g., weather severity, late ETA, limited daylight) for each prediction to build trust and aid decision-making. Record all predictions, threshold crossings, alerts, user overrides, and executed recommendations in an immutable audit log with timestamps and actors. Provide searchable views and export (CSV/API) with retention controls, redacting PII where not required. Include integrity checks and versioning for model/config changes to support dispute resolution and continuous improvement.
Deliver a responsive dashboard that lists all active jobs with their SLA probability, risk tier, route ETA, and daylight/weather overlays. Enable sorting, filtering (by crew, region, due time, risk level), bulk selection, and quick actions. The job detail view presents a timeline with key factors, confidence bands, recommended mitigations, and the ability to trigger actions. Ensure accessibility (WCAG 2.1 AA), internationalization for time/date formats, and accurate timezone handling across regions.
Auto-groups nearby addresses into optimized runs with turn‑by‑turn order. Assign or reassign an entire bundle in one click to slash windshield time and lift daily throughput.
Automatically groups scheduled inspections and estimates into geographically tight bundles based on real travel times, proximity, service duration per stop, job priority, and crew capacity. Integrates with RoofLens job data (address, roof complexity, required skills, appointment windows) to produce balanced daily runs that minimize windshield time while maximizing stops per crew. Supports exclusion rules, minimum/maximum bundle sizes, and manual overrides without breaking optimization constraints.
Optimizes the stop order within each bundle using traffic-aware routing and configurable service times to produce the fastest feasible route. Generates turn-by-turn directions, ETAs, and distance metrics, with deep links to preferred navigation apps for mobile execution. Persists route sequences back to the job records for accountability and repeatability, and provides fallback routing if third-party map services degrade.
Enables assigning an entire route bundle to a crew or adjuster in a single action, updating calendars, capacity, and workload automatically. Supports rapid reassignment when crews change or issues arise, triggering notifications (in-app, SMS, email) and syncing to mobile devices. Maintains an audit trail of assignments and timestamps for operational visibility.
Respects appointment time windows, daylight hours, crew skill certifications (e.g., drone pilot), and equipment constraints (ladder size, drone availability) during bundling and routing. Validates constraints up front, flags conflicts, and proposes alternative runs that remain feasible. Incorporates soft vs. hard constraints and allows per-job overrides with clear impact indicators on ETA and utilization.
Provides a split map/list interface that visualizes color-coded bundles, stop sequences, and ETAs. Allows drag-and-drop of addresses between bundles or within a bundle to adjust order, with instant recalculation of route time, miles, and feasibility checks. Includes undo/redo, conflict warnings, and hover details (service time, notes, roof type) to streamline manual fine-tuning.
Monitors in-day events (cancellations, no-shows, delays, weather advisories) and offers fast re-optimization of a single bundle or the full schedule while preserving completed and locked stops. Syncs changes to assigned crews in real time with updated ETAs and navigation links, and highlights downstream impacts to customer time windows and crew capacity.
Tracks key metrics such as total drive time, miles, stops per day, on-time percentage, and route utilization per crew and date range. Compares Route Bundles performance against manual baselines to quantify windshield time reduction and cost savings. Offers exportable reports and dashboards that surface recurring bottlenecks, informing future capacity planning and territory design.
Layers hail size, wind swaths, and claim density on the triage board. Instantly spot high‑impact clusters and move them to the top, ensuring the worst‑hit customers are served first.
Integrate with one or more third‑party weather providers to ingest hail size and wind swath datasets on a scheduled basis (hourly when available, minimum daily). Normalize all inputs to a common geospatial reference (WGS84), unify schemas, deduplicate overlapping sources, and store as versioned time‑series layers with source, timestamp, and confidence metadata. Implement data quality checks, backfill the last 36 months for historical analysis, and provide failure alerts with automatic retries. Expose a query service optimized for tiled rendering and time‑window filtering to supply the GeoHeat overlay and downstream scoring.
Aggregate claim/job locations from RoofLens projects, supported CRMs, and optional CSV import into a privacy‑safe geospatial grid (configurable geohash precision). Geocode and deduplicate records, apply tenancy isolation, and enforce minimum bucket thresholds to prevent re‑identification. Support filters by status (e.g., open, pending, closed) and event date, and refresh aggregates on a 15‑minute cadence. Produce heatmap‑ready tile data with counts and normalized intensity for consumption by the overlay and impact scoring engine.
Provide interactive map controls to toggle hail, wind, and claims density layers; adjust opacity; reorder layer stacking; and select time windows via a date range slider or event picker. Include a color legend with units (inches for hail, mph for wind) and threshold filters to hide low‑impact areas. Implement hover tooltips with localized values at cursor, responsive layouts for desktop/tablet, keyboard navigation, and persistence of user preferences per account. Ensure smooth pan/zoom with lazy tile loading and graceful fallback when data is temporarily unavailable.
Compute a per‑cell impact score by combining normalized hail intensity, wind speed, and claims density using configurable weights. Detect spatial clusters of high‑impact cells (e.g., DBSCAN/HDBSCAN), output cluster centroids and bounds, and attach human‑readable explanations (e.g., hail 2.0 in, wind 60 mph, density 12/mi²). Expose scores and clusters via API to the triage board, and allow admin‑level tuning of weights and thresholds with versioned configurations. Recalculate incrementally as new data arrives and cache results for fast retrieval.
Integrate impact scores with the triage board to automatically sort jobs, flagging "High Impact" cases above a configurable threshold. Provide bulk actions to move clustered addresses to the top, preserve manual overrides with an audit trail, and display score explanations inline for transparency. Support tie‑breakers (e.g., customer tenure, open claim status, SLA breach risk) and allow disabling at the user or workspace level via feature flags.
Pre‑render raster/vector tiles for hazard and density layers with CDN-backed caching and delta updates to meet p95 overlay tile load times under 500 ms and maintain interactive map panning at 45+ FPS on modern hardware. Implement client/server caching, ETags, and compressed payloads; degrade to last‑known tiles during provider outages; and instrument end‑to‑end telemetry with alerts on SLO breaches. Include load testing and capacity planning to support concurrent surge usage during major storm events.
Configure carrier, jurisdiction, or franchise rules that set priority, due times, and required line items. Enforce consistency at scale and reduce back‑and‑forth with carriers.
A web-based interface to compose, validate, and publish rules that set priority, due times, and required line items based on carrier, jurisdiction, franchise, and claim attributes; supports condition/action blocks, templates per carrier, rule precedence and scoping, draft vs. published versions, schema validation, conflict detection, tagging, and change history; integrates with the estimate creation pipeline and permissions model to control who can create, review, and publish rules.
A stateless, horizontally scalable service that evaluates published rules at key events (intake, estimate creation, line-item edits, submission), producing normalized outputs for priority, due times, and required line items; guarantees deterministic ordering and conflict resolution, idempotent outcomes, and performance SLA under 50ms per evaluation; exposes API and event hooks, supports caching, retries, and metrics, and records evaluation context for auditing.
Automated resolution of carrier, jurisdiction, franchise, and claim type from intake data using address geocoding, policy metadata, and integration mappings; normalizes fields into a canonical model for rule conditions, handles fallbacks when data is incomplete, and exposes a mapping catalog with versioning and access controls to ensure the correct rule set is selected every time.
Mechanisms to auto-add required line items defined by rules with default quantities and notes, present a compliance checklist, block estimate submission if items are missing, and allow role-based override with mandatory reason and attachments; logs all overrides for audit and supports mapping to standard code sets (e.g., Xactimate) to ensure carrier-aligned outputs.
A calculator that derives due dates from rule-defined SLAs while honoring time zones, business hours, weekends, carrier/jurisdiction holidays, and daily cutoff times; updates task deadlines and notifications, recalculates when inputs change, provides a visible countdown in the job view, and includes an API and UI to manage calendars per carrier and franchise.
A safe environment to test rules against sample or live payloads with a visual trace of which conditions matched, what actions fired, and the final outputs; supports version-to-version comparisons, saved test suites, fixture generation from real jobs, and read-only simulation in production to validate changes before publishing.
Immutable logging of rule versions, inputs, evaluation results, user actions, and overrides with timestamps and IDs; provides searchable history, exportable CSV/PDF reports per carrier or jurisdiction, and one-click evidence packs attached to the estimate to streamline dispute resolution and demonstrate adherence to carrier requirements.
When new rush jobs arrive, intelligently reshuffles priorities and reassigns work while honoring locks and user preferences. Notifies affected users with clear reasoning to minimize confusion.
Implements a configurable scoring and rules engine that continuously evaluates incoming and in-flight jobs to determine updated priorities and optimal assignees. Consumes attributes such as rush flag, due dates, customer tier, revenue impact, job complexity, geographic proximity, and required skills to calculate a deterministic score and ordering. Produces a ranked work queue and recommended assignments that align with business objectives and SLAs. Supports admin-configurable weighting, hard/soft constraints, tie-breakers, and skill/territory filters. Integrates with RoofLens job intake, scheduling, and user directory to fetch real-time availability and capacity. Provides versioned rule sets and a test harness for safe iteration and regression checks. Expected outcome is consistent, objective prioritization that reduces manual triage and accelerates turnarounds.
Enforces user- and job-level constraints during reshuffles, ensuring Smart Rebalance never violates hard locks (e.g., do-not-move assignments, in-progress tasks) and always honors user preferences (working hours, PTO, do-not-disturb windows, preferred job types, territory, and skill certifications). Models capacity limits, max concurrent jobs, and equipment requirements to prevent overallocation. Surfaces conflicts with clear reasons and automatically seeks valid alternatives; if none exist, escalates via rules (e.g., request override approval). Integrates with user profiles, calendar availability, skill matrix, and geo/territory data sources to maintain accurate constraints. Outcome is trust in the system through predictable, policy-compliant reassignments.
Delivers clear, actionable notifications to all affected users whenever Smart Rebalance modifies priorities or assignments. Messages include what changed, why it changed (e.g., rush job arrival, SLA breach risk, rule fired), when it takes effect, and suggested next steps. Provides in-app announcements, inbox threads with change diffs, and optional email/mobile push with deep links back to updated queues. Supports batching to reduce noise, localization, quiet-hours compliance, and user-level preferences for channels and frequency. Integrates with the reason-code output from the rules engine to generate human-readable explanations and with the audit trail for traceability. Expected result is high user understanding and minimal confusion during reprioritizations.
Provides a safe-apply workflow for schedule changes: simulate a rebalance to preview impacts (assignment diffs, priority deltas, conflicts), then apply all changes atomically to avoid partial updates. Ensures idempotent operations, optimistic concurrency control, and consistent state across services. Implements automated rollback on failure and a manual revert option, both linked to a specific rebalance transaction ID. Includes guardrails such as change thresholds, circuit breakers, and retry policies to protect active work. Integrates with scheduling, notifications, and audit services so previews mirror real outcomes before committing. Outcome is reliable, low-risk reshuffling that preserves user confidence and operational continuity.
Captures an immutable, searchable record of every rebalance event, including before/after queues, assignments, scores, fired rules, triggering signals, approvers, and notifications sent. Standardizes structured reason codes and human-readable summaries to explain each change. Supports filtering by user, job, timeframe, and rule version, and exports to CSV/PDF for sharing with clients or carriers to reduce disputes. Applies retention policies and access controls to protect sensitive data. Integrates with incident tracking and analytics for trend analysis on rush volume, rule effectiveness, and SLA adherence. Expected outcome is transparent, defensible decision history that builds trust with internal teams and external stakeholders.
Meets defined performance budgets so rebalances complete quickly even during intake spikes. Targets p95 end-to-end recompute under 3 seconds for 1,000 open jobs and 50 active users, with graceful degradation and backpressure under extreme loads. Implements efficient data access patterns, incremental recalculation, and horizontal scaling of the scoring service. Ensures concurrency safety when multiple triggers occur (e.g., simultaneous rush jobs) through queuing, deduplication, and merge strategies. Provides observability with metrics, traces, and alerts tied to SLOs for throughput, latency, and error rates. Outcome is responsive, reliable behavior that minimizes user disruption and keeps estimators productive.
Logs the rationale behind every priority and assignment (hail metrics, due date, drive‑time, rule hits). Export a shareable record to defend decisions with carriers and management, reducing disputes.
Automatically capture every triage decision (priority score, assignment, route choice) with timestamp, actor (user or automation), source system, and full input signal set including hail metrics at the service address and time, due dates and SLAs, drive-time estimates, rule hits, and prior values. Persist correlation IDs to link related operations, include ruleset/model versions and data source provenance, and support reliable ingestion via pub/sub with retry and offline queues to prevent data loss. Integrates with the existing triage service and job lifecycle events to ensure complete coverage across manual overrides and automated workflows.
Define and implement a structured, versioned schema for triage rationale that normalizes common inputs (hail size/intensity, storm date/time, distance/drive-time, due date/SLA, rule hits, model scores) into typed fields with units, confidence, and provenance. Ensure tenant isolation, backwards compatibility through schema versioning, and support for geospatial and temporal context. Provide an abstraction layer that maps source-specific data into canonical fields to enable consistent querying, analytics, and cross-job comparisons.
Store triage rationales in an append-only, tamper-evident log with per-job versioning that captures initial decisions, subsequent overrides, and re-triage events. Chain entries with cryptographic hashes, record rule/model versions, and provide consistent point-in-time snapshots for export. Enforce retention policies, soft-deletes via tombstones, and server-side encryption with key management. Optionally leverage object lock or WORM-capable storage for compliance to meet carrier audit expectations.
Enable attaching and linking supporting evidence to each decision version, including hail history maps and metrics, storm event data, drive-time screenshots, rule evaluation traces, and imagery thumbnails. Store references via secure URIs with signed, expiring links, enforce file type/size limits and malware scanning, and render safe previews in-app. Maintain data lineage and source attribution, and ensure each attachment is bound to the specific decision version for accurate reconstruction.
Generate exportable audit trail reports in PDF and CSV that include a summary, detailed decision timeline, normalized rationale fields, rule/model versions, and linked or embedded evidence. Provide one-click share links with expiring tokens, email/API delivery, configurable redaction profiles, watermarks, timestamps, and tenant branding. Support carrier-specific templates, localization/time zones, pagination for large jobs, and deterministic outputs for a given version to ensure consistency across reviews.
Capture and persist a detailed rule engine evaluation trace for each triage decision, including rules evaluated, matched conditions, thresholds, input values, and contribution to the final score or assignment. Record ruleset identifiers and versions (e.g., Git commit), generate human-readable explanations, and provide diff views between versions to highlight changes affecting outcomes. Where ML models are used, include feature importances or SHAP-style summaries within storage and exports.
Implement role-based access control for viewing, querying, and exporting audit trails with per-tenant policies. Provide granular redaction settings for PII and sensitive business fields in both UI and exports, with audit logs of who viewed or exported what and when. Support legal holds, consent flags, IP allowlists for share links, and watermarking that embeds viewer identity to deter unauthorized redistribution.
One-tap AR corridors auto-generated from the roof outline and camera FOV set your ideal passes, gimbal angles, and overlap targets. Get airborne in under a minute with a plan that guarantees full-facet coverage and consistent capture across steep, complex roofs—no manual patterning required.
Algorithmically generates flight corridors from the RoofLens roof outline, camera FOV, and target frontlap/sidelap to ensure full-facet coverage with minimal turns. Computes pass spacing, altitude, and corridor orientation (ridge-parallel or perpendicular) based on roof geometry, pitch, and multi-level structures. Produces an ordered pass plan with corridor width, speed guidance, and recommended gimbal pitch per pass. Handles complex shapes, dormers, and steep slopes, with constraints for turn radius and clearance from edges. Integrates with job records so plans are saved, versioned, and reusable offline, regenerating in under three seconds after parameter changes.
Renders the generated corridors as 3D AR lanes locked to the roof using ARKit/ARCore sensor fusion with GNSS/IMU and the RoofLens roof outline as the world anchor. Supports quick alignment via user-placed anchor points (e.g., ridge apex) and dynamic re-anchoring to correct drift, maintaining sub-meter visual alignment. Provides directional arrows, lane width guides, and pass numbers with high-contrast, sunlight-readable styling and occlusion handling around chimneys and trees. Monitors alignment quality and prompts recalibration when thresholds are exceeded. Operates at smooth frame rates and degrades gracefully in low-texture or low-light conditions.
Offers a single action to auto-create the corridor plan using the active camera profile, target overlap, and safety constraints, then presents a concise summary (passes, estimated time, altitude range, battery count). Enables rapid adjustments for overlap %, pass orientation, minimum edge clearance, excluded areas, and speed, with instant re-generation. Works offline using cached roof outlines and device profiles, auto-saves to the RoofLens job, and supports undo/redo. Provides a preflight confirmation flow that checks connectivity to the aircraft and validates plan parameters before entering capture mode.
Automatically computes gimbal pitch for each pass to maintain a consistent off-nadir angle relative to local roof pitch and facet orientation. Sets camera exposure, focus, and shutter speed targets based on motion-blur limits for the planned ground speed and lighting, locking white balance and exposure to ensure uniformity across passes. Applies settings via supported SDKs (e.g., DJI, Skydio) with verification and fallback guidance where APIs are limited. Records applied settings into EXIF and the job log for downstream processing and dispute reduction. Allows safe user overrides with guardrails and restores defaults post-flight.
Projects the real-time camera footprint onto the roof mesh to compute achieved frontlap/sidelap and coverage completion during flight. Displays an on-device heatmap and completion percent, issuing alerts for gaps or off-target overlap and suggesting recovery passes before landing. After flight, runs a verification pass that confirms coverage against thresholds and generates a coverage report saved to the RoofLens job and available in exported PDFs. Uses telemetry, pose, and image timestamps to reconcile any deviations from the planned corridors for auditability.
Enforces geofencing and user-defined keep-out polygons with altitude and lateral buffers around obstacles derived from the roof model and detected structures. Suggests pass direction based on wind to reduce crosswind drift and ensures battery reserves with RTH triggers based on plan progress. Runs preflight checks for GPS health, compass status, firmware compatibility, and SDK connectivity, pausing guidance on signal degradation and prompting safe recovery actions. Logs safety events and plan deviations into the job timeline for compliance and insurance documentation.
Live wind and gust sensing adapts headings, speed, and pass spacing on the fly. Visual and haptic prompts help counter drift and yaw so overlap stays on target, reducing blurry shots, re-flys, and battery swaps in breezy conditions.
Derive real-time wind speed and direction at the aircraft using onboard telemetry (IMU, GPS drift, attitude, thrust) fused with localized weather data as fallback. Provide a continuously updated wind vector (≥2 Hz), latency <200 ms, and a confidence score. Expose the vector to guidance, pathing, and safety subsystems via a unified interface in the RoofLens flight app. Include calibration routines, sensor sanity checks, and graceful degradation when signal quality is low.
Continuously adjust headings, ground speed, and waypoint timing to counter crosswinds and gusts while maintaining survey geometry. Apply rate-limited setpoint changes to avoid aggressive maneuvers, respect geofences and roof perimeters, and comply with DJI/Autel SDK constraints. Fall back to guidance-only mode (no direct control) when SDK control is unavailable. Ensure deterministic behavior with reproducible parameters per job and seamless resume after temporary loss of link.
Dynamically compute and adjust lane spacing to maintain target sidelap/forward lap thresholds (e.g., 70%/80%) under varying winds. Differentiate upwind vs. downwind passes, compensate for yaw-induced footprint skew, and re-space subsequent passes when drift exceeds limits. Surface the effective spacing to the UI and log changes to the job for auditability.
Provide on-screen vectors, color-coded guidance bars, and configurable haptic feedback that prompt micro-corrections to counter drift and yaw during manual or semi-autonomous flight. Ensure cues are legible in sunlight, minimally intrusive, and accessible (contrast and vibration patterns). Operate offline with cached assets and degrade gracefully if sensor inputs are limited.
Compute real-time coverage and image quality risk using ground speed, shutter speed, GSD, motion profile, and live wind vector. Display a quality meter, predict gap risk, and take protective actions: auto slow-down, adjust trigger rate, mark segments for redo, or pause capture if thresholds are violated. Emit alerts and log all interventions to support QA and dispute reduction.
Maintain wind-aware energy budgeting and return-to-home (RTH) reserves, forecasting consumption for each leg under headwind scenarios. Reorder or shorten passes to reduce upwind exposure when reserves are tight, and enforce configurable no-fly thresholds (gust limit, max tilt, GNSS quality). Trigger auto-pause/RTH when safety margins are breached and record the rationale in the flight log.
Capture wind vectors, replanner adjustments, pass spacing changes, overlap metrics, blur risk events, and operator overrides. Sync logs to the RoofLens job record and generate a concise QA summary that can be attached to the PDF bid or exported (CSV/JSON). Provide post-flight heatmaps for overlap and motion blur likelihood to guide re-fly decisions and team training.
A real-time forward/side overlap gauge overlays your corridor. If coverage dips below threshold, lanes turn red and the app nudges you to slow, tighten, or add a pass—producing reconstruction‑ready photo sets that eliminate QC failures.
Compute forward and side overlap continuously at 1 Hz or higher from aircraft telemetry (position, altitude AGL, groundspeed, yaw, gimbal pitch/roll), camera intrinsics/extrinsics, and trigger interval. Detect dips below user-defined thresholds and expose normalized metrics (0–100%) to the UI and guidance logic via a local API. Support nadir and oblique capture, variable altitudes, and terrain following (using DSM if available or flat-earth fallback). Fuse RTK accuracy when present; degrade gracefully with standard GNSS by inflating uncertainty bands. Time-align shutter events with vehicle motion to account for motion blur and rolling shutter. Persist a per-pass coverage buffer to enable backtracking and post-flight reporting.
Render the planned flight corridor with lane centerlines and dynamic polygons on the live map/video overlay. Color-code lanes based on computed overlap (green=meets, amber=at-risk, red=below threshold). Display an at-a-glance gauge for forward/side overlap and a mini-map showing current swath vs planned. Support pinch-zoom, north-up/track-up, high-contrast and colorblind-safe palettes. Maintain <100 ms UI latency from metric update to on-screen change. Operate offline with cached basemaps and job footprints. Allow quick toggles to show/hide overlays for de-cluttering.
Provide unobtrusive, actionable prompts when overlap risk is detected, suggesting to slow down, tighten lane spacing, or add a pass. Use haptic, audio, and on-screen cues with rate limiting to avoid alert fatigue. Adapt recommendations based on wind, groundspeed variance, camera trigger rate, and remaining battery. Offer one-tap actions for common adjustments (e.g., reduce speed to X m/s, shrink lane spacing by Y%). Log each nudge and pilot response for QA and continuous improvement.
Allow configuration of forward/side overlap thresholds via selectable profiles (2D orthomosaic, 3D model, steep roof) with editable defaults. Auto-suggest thresholds based on altitude, camera FOV, and job type from RoofLens. Provide a quick calibration flow to verify trigger interval vs speed before takeoff. Persist per-organization defaults and enforce minimums set by admins. Expose thresholds via API for integration with mission planners.
Generate a per-mission QC report summarizing achieved forward/side overlap distributions, heatmaps of low-coverage areas, and a list of recommended recovery passes. Export as PDF for customers and JSON for automation. Attach the report to the RoofLens job and block upload if critical gaps are detected (admin-configurable). Include telemetry stats, camera model, RTK status, and timestamps to streamline audits and dispute resolution.
Ensure Overlap Guardian functions without network connectivity, including metric computation, overlays, nudges, and local caching of basemaps and job boundaries. Detect GNSS degradation and switch to conservative guidance, pausing nudges that could compromise safety. Fail closed: never issue prompts that conflict with obstacle avoidance or airspace rules. Provide a low-power mode that keeps metrics accurate while minimizing device and aircraft battery impact.
Computer vision identifies roof facets, dormers, valleys, and penetrations from the live feed, pinning any uncaptured surfaces with AR markers. Prompted obliques ensure all loss‑critical features are documented for accurate measurements and damage mapping.
Implements a low-latency computer vision pipeline that detects and segments roof facets, dormers, valleys, ridges, eaves, and penetrations directly from the live drone feed. Generates vectorized, georeferenced polygons with per-edge classification and maintains temporal consistency across frames for stable overlays. Integrates with RoofLens’ measurement engine to auto-compute areas, pitches, and linear totals, and exposes structured outputs for downstream damage mapping and estimating. Targets sub-200ms end-to-end inference latency on recommended field hardware and supports graceful degradation to frame-skip mode on lower-end devices. The outcome is accurate, real-time feature extraction that reduces manual tracing and accelerates end-to-end estimate creation.
Automatically identifies occluded or insufficiently observed roof surfaces during capture and pins persistent AR markers at their estimated 3D locations, guiding the operator to revisit and document them. Uses device pose (IMU/visual-inertial odometry) and drone telemetry for world anchoring, updates marker states as coverage improves, and removes markers once quality thresholds are met. Integrates with session completeness metrics and the capture checklist, feeding coverage heatmaps to ensure all surfaces required for measurement and damage assessment are documented. Expected outcome is higher dataset completeness with fewer return visits and reduced dispute risk.
Provides dynamic prompts for required oblique angles and vantage points to document loss-critical features such as step flashing, valleys, and penetrations. Computes recommended headings, gimbal tilt, altitude, and standoff distance based on detected geometry and coverage gaps, and delivers clear on-screen cues with optional audio/haptic feedback. Enforces minimum imaging standards (GSD, overlap, angle of incidence) and adapts to airspace and geofence constraints. Integrates with the flight workflow, session scoring, and quality gates before measurement export. Outcome is consistent, insurer-acceptable imagery that supports accurate measurements and defensible damage mapping.
Attaches per-feature confidence scores to each detected polygon and edge class, highlights low-confidence areas in the UI, and provides fast editing tools to adjust boundaries, add missing features, or reclassify edges. Tracks edits with an audit trail and propagates changes to measurements, damage maps, and line-item estimates in real time. Offers tunable thresholds to require operator confirmation before export when confidence is below policy limits. Outcome is transparent, controllable automation that preserves accuracy and trust while minimizing rework.
Ensures accurate scaling by auto-deriving intrinsic camera parameters from EXIF and self-calibration routines, correcting lens distortion, and fusing drone altitude/RTK GNSS and pose data to anchor measurements. Performs drift detection across the session, prompts for corrective passes if error exceeds thresholds, and validates outputs against known references (e.g., measured ridge length) when available. Integrates with the measurement engine and exports calibration metadata with the report for auditability. Outcome is consistent, verifiable dimensional accuracy across devices and flight conditions.
Provides an on-device inference mode for low-connectivity sites using optimized models (quantization/pruning) and a lightweight tracking pipeline, with deferred synchronization to the cloud once a connection is available. Maintains feature parity for essential functions: detection overlays, AR markers, guidance prompts, and local caching of edits and metadata. Implements conflict resolution and checksum-based verification during sync to preserve data integrity. Outcome is reliable field operation regardless of network conditions, preventing capture interruptions and data loss.
AR altitude bands lock in the ideal height for target GSD and local airspace rules. Audible cues alert if you stray high or low, keeping scale accuracy tight and preventing reshoots due to inconsistent image resolution.
Automatically computes an optimal altitude band (min/max AGL) from a target ground sample distance (GSD), camera intrinsics (sensor size, focal length, resolution), and lens distortion profile. Applies safety margins for sensor noise and environmental drift to keep scale accuracy within tolerances required by RoofLens measurement algorithms. Exposes an API and UI control to set target GSD from job templates and mission presets, supports metric/imperial units, and writes the selected band into the flight plan so downstream capture, processing, and PDF estimate generation use consistent resolution assumptions.
Constrains the altitude band to local airspace rules and terrain-adjusted ceilings by combining airspace advisories (e.g., facility maps, geofences) with a local digital elevation model (DEM) to compute true AGL limits along the flight area. Validates requested bands against maximum allowable altitude, minimum safe altitude over obstacles, and mission geofence; provides actionable alternatives if the band is not permitted. Caches advisories and DEM tiles for offline use and records the applied constraints into the job metadata for auditability.
Renders a low-latency augmented reality overlay in the flight view that visually depicts the target altitude band as color-coded horizontal guides with real-time numeric readouts. Shows clear in-band/out-of-band states, supports high-contrast and colorblind-safe palettes, adapts for portrait/landscape orientations, and remains legible under glare. Integrates with mission HUD elements without obscuring critical telemetry and scales appropriately across supported mobile devices and drone SDK live feeds.
Provides configurable audible alerts when altitude drifts near or outside the band, with hysteresis to prevent alert spam. Includes progressive tones and optional voice prompts (e.g., "ascend 3 meters") that operate offline and respect device audio settings. Allows users to set sensitivity thresholds per mission template, temporarily mute cues, and auto-escalate alerts if deviation persists. Logs all alerts with timestamps for later review in the RoofLens job record.
Delivers stable and accurate above-ground-level (AGL) readings by fusing barometer, GNSS/RTK, and manufacturer-provided height sensors using a Kalman filter with bias correction. Calibrates at takeoff using known ground elevation from DEM and continuously adjusts for pressure changes and GPS drift. Outputs high-rate (≥10 Hz) altitude to drive AR overlays and audible cues, with health diagnostics (e.g., sensor trust scores) and graceful degradation when one or more inputs are unavailable.
Captures and stores mission-level adherence metrics including time-in-band percentage, min/max altitude, average deviation, and out-of-band events. Embeds these metrics into the RoofLens job record and exposes them in processing dashboards, exports (CSV/JSON), and optional PDF bid appendices to provide evidence of consistent image resolution. Flags missions with poor adherence for reshoot review and feeds quality signals into automated measurement confidence scoring.
Auto-builds a coverage heatmap and gap list on landing. Tap any gap to launch a micro-mission that fills it in 1–2 passes, then generate a QC pass certificate—fixing issues on-site and stopping costly drive-backs.
Automatically generates a georeferenced coverage heatmap upon drone landing by analyzing captured imagery and flight logs to compute area coverage, overlap percentage, ground sampling distance (GSD), and camera angle compliance against job-specific thresholds. Renders an interactive overlay on the job map inside RoofLens, updates the job’s QC state, and persists tiles and metrics for audit. Supports progressive updates during flight where telemetry is available and seamlessly associates images with the active job.
Identifies uncovered or underqualified regions by evaluating coverage, overlap, GSD, and obliquity thresholds per roof facet. Produces a ranked list with coordinates, approximate size, affected measurements (e.g., ridge length, area), and a severity score tied to expected estimation error. Thresholds and ranking weights are configurable per organization or template. Exposes in-app filters and updates in real time as new imagery is added.
Enables one-tap generation of short corrective flight plans for a selected gap. Plans 1–2 efficient passes with required altitude, path width, speed, and gimbal angle to meet QC thresholds, taking into account known obstacles, site boundary, no-fly zones, remaining battery, and local regulations. Provides a preflight checklist and on-screen preview, supports send-to-drone via supported SDKs, and streams mission telemetry back to update the heatmap and audit logs.
Executes heatmap generation and gap detection entirely on-device when connectivity is limited, using cached basemaps and configuration. Queues assets and metrics for background sync to the cloud when a connection is available, with conflict resolution and deterministic reprocessing to ensure parity between edge and cloud results. Provides clear offline indicators and guards against data loss on app close.
Validates that post-correction coverage meets configured QC thresholds and produces a tamper-evident QC Pass Certificate in PDF and JSON formats. Includes site boundary, coverage/overlap/GSD metrics, before/after gap list, timestamps, pilot and aircraft identifiers, firmware versions, weather snapshot, and signed hashes of flight logs and imagery. Attaches the certificate to the RoofLens job, embeds a summary in exported bids, and supports shareable links. If thresholds are not met, generates a QC Fail report with remediation guidance.
Supports team operations by sharing the live heatmap and gap list across nearby devices, allowing operators to claim gaps and assign micro-missions. Implements soft locking and mission deconfliction to prevent duplicate work and reduce collision risk, including temporal separation and minimum distance rules for multiple aircraft. Synchronizes over local network or cloud when available and records assignments and outcomes for audit.
Adds a scannable QR and short link to every DisputeLock PDF that opens a lightweight verification page. Adjusters confirm authenticity in seconds—hash match, capture timestamps, and signer list—without installing anything. Cuts back‑and‑forth and speeds approvals while preserving offline PDF workflows.
Embed a unique, high-contrast QR code and human-readable short link into every DisputeLock PDF at render time. The QR encodes a signed verification token and short URL; the printed short link offers a manual fallback. Placement is consistent across templates (e.g., footer margin), sized for camera readability and print/scan resilience (adequate quiet zone, ECC level M/H). The element is version-aware (new code per regenerated PDF), themeable with account branding, and configurable per account or document type. The injection runs in the existing PDF generation pipeline without altering core content layout or pagination and degrades gracefully for legacy PDFs.
Serve a lightweight, public, mobile-first page that loads in <1s on average 4G, displaying cryptographic hash match status (pass/fail), capture timestamps, signer list, and key document metadata. Provide clear visual status (green check/red alert), company branding, and print-friendly layout. The page requires no authentication, supports accessibility (WCAG 2.1 AA), respects privacy configurations (e.g., masking sensitive fields), and works across default phone camera QR scanners and modern browsers. Include timezone-aware timestamps, a verification ID, and a contact link for disputes.
Generate a SHA-256 hash of the finalized PDF bytes and store it with version metadata in a write-once audit store. Issue a signed, time-bounded verification token embedded in the QR/short link. The verification endpoint recomputes the hash from the canonical document, validates the token signature and expiry, and returns pass/fail with reason codes (e.g., mismatch, expired, unknown). Prevent token guessing/enumeration and avoid PII in URLs. Support re-issue on document regeneration while preserving historical versions for compare.
Aggregate and persist an immutable audit trail for each DisputeLock document: creation/finalization timestamps, signer list and signing events, and key lifecycle events (e.g., edits, regenerations). Encrypt at rest, apply retention policies, and expose a minimal subset on the verification page (per privacy settings). Provide a structured, downloadable audit JSON for internal use while keeping the public page concise. Ensure consistency with existing DisputeLock audit data to avoid duplication.
Create a reliable short-link service that generates non-sequential, collision-resistant IDs (e.g., base62), protected against enumeration and abuse. Support account-level custom domains (e.g., verify.contractor.com), HTTPS-only redirects, and CDN-backed global edge routing for availability. Include manual entry fallback via the printed code and handle 404/expired states gracefully with guidance. Log scan and visit events for operational insights without exposing PII.
Limit public verification content to the minimum necessary, with optional project-level PIN or claim-number allowlist to reveal extended details. Enforce strong CSP, HSTS, and no third-party trackers/cookies; implement rate limiting and basic bot mitigation on the verification endpoint. Provide configurable redaction (e.g., mask homeowner contact info) and clear legal disclaimers. Maintain detailed server logs for forensics while respecting data protection obligations (GDPR/CCPA) and honoring data deletion/retention policies.
Embeds an append‑only chain‑of‑custody record showing who captured, uploaded, edited, approved, and shared each report—complete with device IDs, GPS/time, and WebAuthn identity. Export or share as an audit sheet to defend evidence handling and reduce scope disputes.
Implement an immutable, append‑only event log for each RoofLens report. Every action that affects evidence or report state (capture, upload, detection, edit, approval, share, export) is recorded as a discrete event containing: event type, actor reference, device ID, UTC timestamp, GPS fix with accuracy, hash of the affected artifact(s), and a cryptographic link to the previous event (hash chaining). Ledger segments are periodically sealed with signed checkpoints to enable efficient verification at scale. All evidence artifacts (images, PDFs, datasets) are content‑addressed (e.g., SHA‑256) to bind their integrity to the ledger. The ledger integrates at the domain layer so all product surfaces (mobile capture, web editor, automation, APIs) emit standardized events. This provides provable non‑repudiation and tamper evidence for dispute defense and compliance.
Require WebAuthn (FIDO2) verification for privileged actions and bind each ledger event to a verified user identity. Store assertion metadata (credential ID, user handle, origin, challenge, sign counter) with the event to support later validation. Support platform and roaming authenticators across web and mobile, including passkeys. For field capture where continuous prompts are impractical, use short‑lived, WebAuthn‑backed session tokens and device keys to co‑sign events, with re‑verification on sensitive steps (approval, export, share). Map identities to org roles to reflect custody responsibilities. This ensures strong, phishing‑resistant identity attribution for chain‑of‑custody.
Capture high‑fidelity context for each event: device identifiers (mobile device model/OS, app version, drone UID/airframe serial), UTC timestamp synchronized via NTP with drift detection, and GPS coordinates/altitude with accuracy and fix quality. For images, extract and store EXIF/XMP alongside computed content hashes; for drones, include flight controller time and location when available. Detect and flag inconsistencies (e.g., EXIF time skew, missing GPS, simulated locations). Clearly mark confidence levels when signals are unavailable and prevent silent fallbacks. This augments the ledger with verifiable spatiotemporal provenance to strengthen evidence defensibility.
Provide an in‑app, per‑report timeline that visualizes the custody ledger as a readable sequence of events with filters by user, device, action type, and time range. Each event entry should link to affected artifacts and render contextual previews (image thumbnails, geometry overlays). For edit events, present before/after diffs of measurements and line items. Surface trust indicators and anomaly flags (e.g., hash mismatch, time gaps, missing GPS). Integrate the timeline into existing report and export views to enable quick audits without leaving the workflow.
Enable one‑click export of the custody ledger as a shareable audit package in PDF, CSV, and JSON. The PDF should summarize key events, include a scannable QR code/deep link to the live verification page, and watermark with report identifiers. The JSON should include event payloads, hashes, and checkpoint signatures to allow offline verification. Generate short‑lived, signed share links with access controls and expiration. Append the audit sheet as an optional section in bid/report PDFs to reduce disputes and support carriers’ documentation requirements.
Introduce fine‑grained permissions governing who can view, export, or share custody details. Support field‑level redaction (e.g., hide exact GPS or device serials) based on recipient role and jurisdiction, while retaining full fidelity internally. Record access events to the ledger to maintain an audit of who viewed or shared custody data. Provide organization‑level policies for retention periods and PII handling to align with GDPR/CCPA and carrier guidelines.
Run scheduled and on‑demand verification that recomputes artifact hashes, validates hash‑chain continuity, and checks WebAuthn assertions and checkpoint signatures. Display verification status and trust badges in the UI and include results in exports. Trigger alerts to admins when anomalies are detected (missing events, hash mismatch, signature failure, clock skew) with guided remediation steps. Provide an API endpoint to retrieve verification reports for external systems.
Generates a clear, color‑coded change summary between versions—line items added/removed, quantity shifts, notes, and attachments. Includes author, timestamp, and reason notes so supplements read like a concise commit history, making negotiations faster and less contentious.
Capture a complete, read‑only snapshot of each estimate revision at save time, including line items, quantities, unit prices, taxes/fees, roof measurements, damage annotations, notes, attachments, and layout metadata. Stamp every snapshot with author ID, timestamp, and an optional reason note, and assign a monotonically increasing version number. Store snapshots in a way that guarantees reproducible diffs and prevents post‑hoc edits, integrating with existing RoofLens estimate entities and permissions so prior versions can be referenced, compared, and exported without data drift.
Implement a diff engine that reliably maps line items between revisions even when items are reordered, renamed, or regrouped. Use stable IDs where available and fallback fuzzy matching on SKU/code, description, unit, category, and price to detect adds, removals, quantity changes, price changes, note edits, and tax/fee impacts. Compute per‑line deltas and totals impact, and identify moved items without double‑counting. Include change detection for section/group headers (e.g., tear‑off, underlayment, flashing) and for measurement‑driven quantities so users can trace quantity shifts back to updated measurements.
Provide an interactive UI that presents diffs with intuitive color semantics (added = green, removed = red, modified = amber) and icons, with side‑by‑side or inline views. Support filters (adds/removes/quantity/price/notes/attachments), grouping by trade or section, search, and expand/collapse for long estimates. Show tooltips with previous → new values and net deltas, and a legend explaining colors. Ensure responsive performance (initial render under 2 seconds for typical estimates), accessibility (keyboard navigation and contrast), and seamless navigation from the estimate screen within RoofLens.
Require an author, timestamp, and a brief reason note when creating a new revision, with optional per‑line change notes. Display these metadata at the top of the diff and alongside individual changes where applicable. Lock notes after save to maintain integrity, and log all actions (who created, viewed, exported, or shared a diff) to the existing audit log. Expose audit entries in the UI for compliance and include them in exports when requested.
Detect and present changes to photos, documents, and drawing annotations between revisions, including added, removed, and updated items. For updated annotations, render before/after overlays of measurement lines and damage polygons with callouts highlighting moved vertices and label edits. Provide thumbnail previews, file metadata, and quick open to full‑size viewers. Tie attachment changes back to affected line items where applicable (e.g., new hail damage photos linked to replacement line items).
Generate a branded, paginated PDF and secure shareable link that capture the diff with color‑coding, metadata header (author, timestamp, reason), legend, and per‑section summaries including net total change. Support company logo/branding, configurable redaction of internal notes, and page anchors for quick navigation. Links should be tokenized with expiration and access tracking, and PDFs should reference immutable snapshot IDs to ensure the report matches the exact compared versions.
Expose REST endpoints to list revisions for an estimate, fetch diff summaries and detailed change sets, and retrieve export artifacts. Support filters (by change type, section, author, time window), pagination, and ETag caching. Provide webhooks that fire when a new revision is created or when a diff is exported/shared, including metadata for downstream CRMs or claims systems. Enforce authentication, rate limits, and audit logging consistent with RoofLens platform standards.
Watermarks each photo, measurement, and page section with verified GPS, time, altitude, and capture confidence. A roll‑up badge summarizes coverage integrity, proving the imagery is job‑specific and unaltered—disarming claims of stock photos or post‑hoc edits.
Build an ingest pipeline that extracts and validates GPS latitude/longitude, timestamp, altitude, and drone telemetry from EXIF/flight logs for every uploaded image and measurement. Cross-check capture coordinates against the job geofence, normalize timestamps to UTC with NTP-backed clock drift correction, and convert altitude to AGL using local elevation data. Compute a capture confidence score based on signal accuracy/HDOP, flight log concordance, device trust, and proximity to the job polygon. Persist a canonical, versioned metadata manifest per asset, flag anomalies (e.g., out-of-bounds, stale clock, edited EXIF), and expose verification results to downstream rendering and reporting services.
Render legible, non-obtrusive watermarks onto every photo, measurement, and report section that display lat/long, capture time (UTC/local), altitude (AGL), and capture confidence. Support dynamic placement to avoid key image content, adjustable opacity/size, light/dark backgrounds, and per-page section stamping in PDFs and the web viewer. Ensure DPI-aware, vector-quality overlays for print, consistent typography across platforms, and localization of time/units. Provide configuration presets (strict, standard, minimal) with project-level defaults and per-export overrides while preserving alignment with the verified metadata manifest.
Generate a cryptographic seal for each asset and exported report by hashing content plus canonical metadata (SHA-256) and signing with a managed private key (e.g., Ed25519/JWS). Embed a compact signature payload and a QR code on each page that links to a verification endpoint. On scan, show signature validity, canonical hash, and a diff check against the uploaded artifact to detect edits. Maintain key rotation, a transparency log of issued seals, and secure key storage (HSM/KMS). Ensure seals survive common file conversions and support offline verification via downloadable manifest files.
Compute and display a roll-up badge summarizing capture integrity across the job: percent roof area covered, photo count, altitude range, average GSD, duplicate/blur rate, time span, and overall capture confidence. Visualize as a color-coded badge (green/yellow/red) with thresholds and tooltips that explain any deficiencies (e.g., gaps over ridge lines, low GPS accuracy segments). Embed the badge in report headers, job dashboards, and export summaries, and expose underlying metrics via API for auditing and automated workflow rules.
Provide a public web portal and REST API where third parties can scan a QR or upload a PDF/photo to verify authenticity. Return signature validity, hash match status, job geofence proximity, capture time window, and any anomaly flags without exposing sensitive customer data. Implement rate limiting, uptime monitoring, audit logs, and a privacy-first data model that redacts PII while still proving provenance. Offer embeddable verification widgets and a webhook for automated status retrieval in claim systems.
Enable admins to configure what metadata appears in visible watermarks (e.g., rounding coordinates, hiding exact timestamps) while preserving the full canonical metadata in the signed manifest. Support policy templates by client/market, role-based overrides, and an auditable redaction log. Ensure any redaction choices are reflected consistently across web viewer and PDFs and do not invalidate the cryptographic seal by using a stable canonicalization layer for signing versus display.
Applies standards‑based digital signatures (PAdES/LTV) from RoofLens and optional co‑signers. Once signed, the PDF is cryptographically locked; any change breaks the seal and flags clearly. Users get long‑term, court‑ready validation without extra tools.
Implement a server-side signing service that applies PAdES Baseline (B-LT) compliant digital signatures to RoofLens-generated PDFs. Embed the full certificate chain, OCSP/CRL responses, and signed attributes to enable long-term validation in standard PDF readers without plugins. Use SHA-256 or stronger algorithms, support multiple digest/signature algorithms, and ensure compatibility with Acrobat/Reader trust stores (AATL/EUTL). Integrate with the PDF generation pipeline so the seal is applied automatically at the end of estimate creation, with optional visible signature appearance and metadata binding to the job, customer, and version. Provide error handling, retries, and idempotency for signature application.
Integrate RFC 3161-compliant TSA providers to attach trusted timestamps to each signature and document (signature-time and document-time stamps). Support at least two redundant TSA endpoints with automatic failover and configurable policies per region/tenant. Embed timestamp tokens within the PDF per PAdES requirements to prove the signing time independent of system clocks. Ensure reliable network performance, audit logging of TSA requests/responses, and graceful degradation if one TSA is unavailable. Expose settings to choose TSA providers and policies.
Provision and manage the RoofLens signing keys in a FIPS 140-2/3 validated HSM or cloud KMS with hardware-backed key protection, strict role-based access controls, and full audit logging. Support key rotation, certificate renewal, and chain management, with alerts ahead of expirations. Allow per-environment and optional per-tenant signing identities, and enable bring-your-own-certificate for qualified customers. Automate CSR generation and issuance with a publicly trusted document-signing CA compatible with common PDF readers’ trust lists. Prevent key export, enforce least-privilege usage, and provide disaster recovery procedures.
Enable inviting external co-signers (e.g., homeowner, adjuster) to sign the same PDF with sequential or parallel routing, configurable order, due dates, reminders, and expirations. Provide identity verification options (email link with one-time code, SMS OTP), ESIGN/UETA consent capture, and a clear signing UI. Apply compliant digital signatures for each co-signer and preserve LTV data for all signatures. Support declinations, reassignments, and cancellation, with secure access links and anti-tamper protections. Integrate notifications and status tracking within RoofLens jobs and expose events via webhooks for external systems.
Once all required signatures are applied, lock the document within RoofLens by setting appropriate PDF permissions and finalizing the signature fields so that any change breaks validation. Display clear in-app verification states (Valid, Modified, or Broken) with explanations and next steps. Prevent edits to sealed versions, forcing new revisions to create a new version and signature cycle. Ensure the sealed PDF shows a clear status in standard PDF readers without additional tools, and surface any validation failures prominently to users and admins.
Implement background jobs to periodically refresh embedded OCSP/CRL data and apply archival timestamps to upgrade documents to PAdES B-LTA where configured. Track revocation info expiry and proactively renew validation data before it becomes stale, even after signers’ certificates expire. Maintain a resilient cache of revocation data, handle large CRLs efficiently, and re-seal with chained timestamps to preserve evidence over time. Provide admin controls for retention policies and compliance reports on validation health across all sealed documents.
Capture a comprehensive audit trail including signer identities, consent records, authentication steps, IP addresses, user agents, timestamps (system and TSA), document hashes before/after signing, certificate details, and validation results. Allow export of an evidence package containing the sealed PDF, audit log, cryptographic hashes, TSA receipts, and verification instructions. Ensure data integrity with tamper-evident logging and secure retention aligned with legal and customer policies. Make audit details viewable in-app for each document and accessible via API for downstream systems.
Enables role‑based, permanent redactions (PII, policy numbers) that maintain a verifiable manifest. Share privacy‑compliant copies with carriers or homeowners without breaking tamper evidence, while keeping a secure, fully detailed original for internal records.
Define and enforce redaction rules by user role, document type, and field sensitivity (e.g., names, addresses, policy numbers) so that shared outputs automatically exclude protected data while internal roles retain full visibility. Integrates with RoofLens RBAC, export pipelines, and PDF generation to apply policies at share/export time and through API. Supports reusable policy templates per carrier and jurisdiction with versioning and change history.
Render redaction regions directly into pixel data and vector content, flatten layers, remove hidden text, sanitize selectable text, and strip content streams so redacted information cannot be recovered. Applies to RoofLens PDFs, annotated damage maps, and aerial images, ensuring irreversible removal across all exported formats, including multi-page estimates and attachments.
Produce a cryptographically signed manifest detailing each redaction (page/coordinate bounds, content classification, policy ID, actor, timestamp, reason) and include SHA-256 hashes of original and redacted artifacts. Embed the manifest and signature in PDF attachments/metadata and expose a verification endpoint and in-app verifier, enabling recipients to confirm integrity and the exact scope of redactions without accessing the original.
Provide time-bound, access-controlled share links and downloadable exports that deliver only the redacted artifacts alongside the verification manifest. Integrate with RoofLens share modal and notifications, support recipient watermarking, optional print/download restrictions, and event logging for views/downloads to meet carrier and homeowner privacy requirements without manual post-processing.
Use OCR and entity recognition to detect and classify PII and domain-specific identifiers (names, addresses, emails, phone numbers, policy and claim IDs) within PDFs, tables, annotations, and images. Pre-populate suggested redaction zones with confidence scores and policy mappings, allowing users to confirm, adjust, or dismiss suggestions before burn-in. Supports language/locale settings and customizable sensitivity thresholds.
Offer an in-document editor to add, resize, and label redaction regions; assign reasons and policies; and view a live side-by-side preview of the final redacted output. Provide keyboard shortcuts, undo/redo, snap-to-annotation guides, and validation that all required fields are covered per selected policy before allowing share/export.
Store immutable originals in separately encrypted storage with strict RBAC, just-in-time access approvals, and full audit trails. Redacted copies are generated on demand; originals are never exposed via share links or downloads. Implement key rotation, secret management, and metadata/EXIF scrubbing to prevent leakage of hidden data across all export channels and APIs.
Automatically maps detected materials and damages to the exact jurisdiction‑ and carrier‑specific line codes (Xactimate, CoreLogic/Symbility, and franchise templates). Uses ZIP/county, policy type, and carrier rules to pick the right codes and units, maintains a versioned crosswalk, and highlights deltas when rules update—reducing rekeys, rejections, and reviewer friction.
Implements a deterministic rules-driven engine that maps RoofLens-detected materials and damages to the exact jurisdiction- and carrier-specific line codes (Xactimate, CoreLogic/Symbility, and franchise templates). Inputs include ZIP/county, carrier, policy type, dwelling type, and detected roof components. The engine applies precedence, exclusions, and conditional logic (e.g., deductible type, repair vs. replace) to select correct codes, units, modifiers, waste factors, and notes. Provides stable, idempotent results, with explicit fallbacks for unmapped items, and flags any confidence gaps. Integrates post-detection in the estimate pipeline and returns a normalized payload: line code, description, UoM, quantity, pricing context, rule reference, and rationale. Supports sub-structures (e.g., detached garage), multi-slope assemblies, and localized code sets. Must compute results within target latency (<2 seconds per job) and expose API/SDK entry points for synchronous and batch use.
Creates a centralized, versioned repository for crosswalk rules with effective-date windows by geography and carrier, template type, and policy constraints. Supports draft/review/publish workflow, role-based permissions, approvals, and rollback. Imports rule updates from carriers, vendor catalogs, and franchise templates; validates schema, detects conflicts, and runs regression checks against fixtures. Each rule is addressable (rule ID), semantically versioned, and annotated with source, citation, and changelog. Projects can be locked to a specific rule version for reproducibility, while allowing later comparison to newer versions. Exposes admin UI and APIs for CRUD, bulk import/export, and automated nightly sync jobs.
Highlights and communicates differences when crosswalk rules change. For each affected estimate, shows a side-by-side diff of before/after codes, units, quantities, pricing context, and notes; indicates reason (rule ID change, effective-date rollover, new carrier guideline). Allows users to preview, selectively accept, or defer updates, and to re-run mapping in batch. Sends configurable in-app, email, and webhook notifications; provides a dashboard of impacted projects with severity ranking. All applied updates are logged with user, timestamp, previous value, new value, and justification for audit and rollback.
Normalizes RoofLens measurement outputs into carrier- and template-specific units of measure and rounding conventions. Applies UoM conversions (e.g., SQ from sqft, LF, EA), waste factors, coverage multipliers, and minimums per material/damage type. Enforces rounding rules (e.g., banker’s vs. conventional), decimal precision, and carrier-specific preferences (e.g., drip edge in LF vs. EA). Validates consistency between quantities and selected codes; surfaces warnings for improbable combinations. Provides a reusable service used by the selection engine and export connectors to ensure consistent, reproducible quantities across all destinations.
Generates ready-to-submit estimate payloads in carrier and franchise-required formats, including Xactimate, CoreLogic/Symbility, and franchise templates. Maps internal normalized line items to destination fields (codes, descriptions, UoM, quantities, notes, price context) and performs preflight validation to catch format or required-field issues. Supports one-click export via UI and asynchronous API jobs, with downloadable files and webhooks on completion. Includes destination-specific test suites and fixtures, schema version negotiation, and graceful error reporting with actionable remediation hints.
Provides end-to-end traceability for every mapped line item, including source rule ID, version, effective dates, and citations. Allows authorized users to override code selection, UoM, or quantity with reason codes and optional attachments, with configurable approval workflows by role and carrier. Records a tamper-evident audit log capturing user, timestamp, previous and new values, and justification. Exposes an exportable audit report and embeds traceability metadata into generated estimate files where supported. Integrates with org-level RBAC and supports policy-based restrictions on override scope.
Keeps unit pricing current and defensible by syncing regional price lists with supplier feeds and storm‑surge adjustments. Flags stale or mismatched lists, shows real‑time margin/variance impact, and can lock to a carrier‑approved schedule per file—delivering up‑to‑date, consistent pricing with clear rationale.
Implement connectors to major roofing suppliers (e.g., API and secure file drop/CSV) to ingest unit pricing, packaging, and UoM data on a scheduled and on‑demand basis. Normalize incoming data to a canonical SKU catalog with region, brand, and packaging mappings; handle currency, UoM conversions, and duplicate resolution. Support API auth (keys/OAuth), rate limiting, retries, and incremental updates with change detection. Provide admin tools for mapping SKUs and reviewing ingestion errors, plus fallbacks for manual upload when an API is unavailable. Ensure validated, normalized prices flow into PricePulse as the authoritative source for downstream pricing and analytics.
Create region‑scoped price lists with versioning, effective/expiry dates, tax/freight/fuel surcharges, and ZIP/postcode‑to‑region mapping. Define selection rules that auto‑assign the correct price list to a project based on job address and organization policies. Provide side‑by‑side diffing between versions, rollback to prior versions, and a full audit log of changes. Expose APIs and UI to manage regions, inherit defaults, and override by branch. Guarantee consistent, defensible pricing across territories and seamless integration with estimate generation.
Build an event‑aware pricing layer that applies temporary, explainable multipliers or offsets by region, category, and SKU during post‑storm periods. Ingest signals from external weather/storm feeds and internal indicators (claims volume spikes, supplier surge flags). Support configurable caps, decay curves, start/end dates, and business rules, with manual overrides requiring rationale. Provide preview/simulation of adjustments before publishing, and record every applied adjustment with its source and parameters. Ensure adjustments integrate cleanly with base lists and are reversible without data loss.
Introduce automated checks that flag stale price lists past freshness thresholds and detect SKU/UoM mismatches between estimates and the active list. Surface inline warnings during estimate creation, provide remediation suggestions (update list, remap SKU, accept exception), and optionally block submission based on policy. Deliver health dashboards and notifications (in‑app/email) for admins with drill‑downs to affected files. Log detections and resolutions for auditability, reducing pricing errors and rework.
Compute and display line‑item and total margins using current costs versus target sell prices, and show variance against a baseline or carrier schedule. Recalculate instantly when switching price sources, applying surge rules, or editing quantities. Provide freshness indicators, delta charts, and what‑if toggles to compare scenarios and understand margin impact before publishing. Enable export of margin/variance summaries into the estimate PDF and CSV for analysis.
Allow an estimate to be bound to a specific carrier‑approved price schedule and version, preserving that schedule for the file’s lifecycle. Enforce read‑only pricing when locked, with role‑based overrides that require rationale and produce a difference report against the carrier schedule. Provide dual pricing view (carrier vs market) and ensure exports include the locked schedule reference and variance breakdown. Maintain compatibility with downstream revisions and supplements without breaking the lock.
Capture end‑to‑end pricing provenance per estimate, including supplier sources, list versions, surge adjustments, overrides, timestamps, and responsible users. Store an immutable audit log and generate an exportable appendix (PDF/JSON) with human‑readable rationale and machine‑readable metadata. Optionally produce a cryptographic hash/signature for tamper evidence and support retention policies and search. Embed references in the bid package to reduce disputes and speed approvals.
Attaches verifiable evidence and reasoning to every line item—cropped, GeoSeal‑verified photos, detected damage labels, measurement references, and relevant code/policy citations. Reviewers can click through in the PDF or verification page for instant context, speeding approvals and strengthening supplements.
Provide capability to attach multiple evidence objects (cropped photos, damage labels, measurement references, code/policy citations, and rationale notes) to any estimate line item. Supports many-to-one mappings, ordering, versioning, and required/optional flags per line item type. Evidence objects are stored as structured entities with metadata (type, source, capture time, provenance). UI indicates attached evidence counts and types; API endpoints allow create/read/update/delete. Export pipeline renders concise badges in the PDF and embeds references for the verification portal. Ensures no single attachment exceeds defined size limits and that total payload remains within export thresholds.
On photo ingest, capture GPS coordinates, timestamp, altitude, device ID, and compute a cryptographic hash. Generate a server-signed GeoSeal that binds metadata to the media and store it with the asset. Display verification status (verified, unverifiable, or mismatched) alongside each image in the portal and as an icon in the PDF. Provide a verification panel showing raw metadata and seal validation results. Detect and flag metadata inconsistencies and post-edit alterations by rehashing on access. Gracefully handle non-GPS or third-party images by marking them as "unverified" while still attachable.
Automatically crop photos to the area relevant to the line item by leveraging detected roof components and damage regions. Provide manual fine-tuning with handles and a before/after toggle. Support annotation overlays (arrows, labels, dimensions) with style presets and maintain a clean, consistent visual standard across exports. Include configurable redaction to blur house numbers, faces, or license plates while preserving the original in a secure archive. Maintain a transformation history to preserve chain-of-custody and allow reversion.
For each line item quantity, provide a clickable reference that traces back to the 3D/2D measurement model: slopes, edges, ridges, valleys, eaves, and penetrations. In the portal, highlight the contributing segments, show measurement totals, unit conversions, and rounding rules applied. Embed static snapshots in the PDF for offline review. Handle revised measurements by versioning and clearly indicating which estimate version each line item references.
Maintain a curated, versioned library of building codes, manufacturer specifications, and insurer policy guidelines indexed by jurisdiction, insurer, product, and effective dates. Suggest relevant citations for a line item based on project address, insurer profile, and detected damage type. Allow users to search, attach, and quote specific sections with deep links. Flag expired or superseded citations and prompt for updates. Provide an admin UI for library maintenance and bulk imports.
Generate PDFs with per-line-item icons that deep-link to a secure verification page containing evidence details, GeoSeal validation, measurement traceback, and citations. Links are signed, time-limited, and revocable. The portal renders fast, mobile-friendly views with pagination for multi-item reviews and preserves the export context. Record link click metrics and return status signals for approval workflows. Provide graceful degradation when links are disabled by including summary evidence snapshots in the PDF.
Implement role-based access controls for viewing, commenting, and downloading evidence. Support organization-level roles (admin, estimator, reviewer, external reviewer) and shareable, expiring links for third parties. Log all access, changes, and exports with timestamps, user IDs, IP addresses, and item references. Provide exportable audit reports and webhooks for approval/denial events. Ensure storage and transmission encryption in line with industry best practices.
Prevents misses and conflicts by scanning the scope against roof geometry, climate zone, and carrier/franchise rules. Auto‑suggests required adds (e.g., ice‑and‑water % by zone, steep/two‑story charges, step flashing at walls) and flags redundancies or incompatible methods—cutting first‑pass errors and disputes.
Centralized engine that evaluates the job context (roof geometry, location/climate zone, carrier/franchise program, selected line items) against a library of rules to produce suggested adds and conflict/compatibility flags. Supports rule types such as Required Add, Threshold, Conflict, and Redundancy. Rules are scoping-aware (by carrier, franchise, program, jurisdiction, climate zone), versioned with effective dates, and have priority/precedence resolution. Provides a JSON/DSL rule format, import/export, and a test harness to validate rules against sample jobs. Ensures fast evaluation (<500 ms per job) and deterministic outputs for auditability.
Maps RoofLens measurement outputs (facets, edges, eaves, rakes, valleys, pitch, stories, wall intersections, penetrations) to validation checks that infer required components and labor charges. Calculates quantities for items like step flashing at walls, drip edge, ridge cap, valley metal, starter, ventilation, steep/two-story charges based on thresholds. Detects missing required items relative to geometry and flags over- or under-quantification. Exposes normalized measurement features to the rule engine with unit conversions and rounding rules.
Determines climate zone and local code context from job address via geocoding and cached datasets (e.g., IECC/NOAA zones, municipality overlays). Maps zones to prescriptive requirements such as ice-and-water shield coverage percentages at eaves/valleys, underlayment types, ventilation ratios, and cold/heat climate practices. Maintains an updatable dataset with versioning and effective dates, and exposes zone-derived constraints to the rule engine. Provides graceful fallbacks when zones are ambiguous and logs data provenance for audits.
Analyzes selected line items to identify mutually exclusive methods (e.g., recover vs tear-off), incompatible materials (e.g., synthetic vs felt underlayment), duplicate entries (e.g., double ridge cap), and overlapping charges (e.g., two steep charges). Assigns severity levels (error, warning, info) and recommends a single corrective action. Integrates with estimate editing to highlight offending items inline and prevents contradictory selections when configured as blocking.
Generates one-click, prefilled line items for required adds based on rules and measurements, including computed quantities (LF/SF/EA), waste factors, and cost codes. De-duplicates against existing scope, merges with compatible items when appropriate, and presents a preview panel to apply all or selective suggestions. Supports organization-specific item catalogs and carrier program templates.
Attaches human-readable rationales to each suggestion/flag, citing the rule ID, data inputs (e.g., pitch 8/12, wall intersection 42 LF, Climate Zone 5), and source references (carrier guideline, code). Persists all rule evaluations, user actions, and versions in a job-level audit log. Exposes explanations in the UI and optionally includes a compliance appendix in exported PDFs for dispute reduction.
Provides role-based controls to accept, dismiss, or override suggestions and to waive blocking conflicts with a required justification note. Supports carrier-locked rules where overrides are disabled, and organization settings to toggle blocking vs advisory behavior. Records user, timestamp, reason, and impact in the audit log and surfaces override summaries in the final estimate.
One‑click assemblies expand into fully quantified line items—starter, drip edge, underlayment, ridge vent, pipe jacks—calculated from RoofLens measurements and local rules. Conditional components toggle based on materials and slopes, with prewritten notes for consistency and speed across teams.
Provide a configurable template builder to define roofing system assemblies composed of components (e.g., starter, drip edge, underlayment, ridge vent, pipe jacks) with quantity formulas mapped to RoofLens measurements (area, eave/rake/ridge/valley lengths, facets, penetrations). Support waste factors, rounding and packaging rules (ceil to bundle/box), min/max quantities, dependencies, and material system presets (asphalt, metal, tile). Ensure templates can be saved, cloned, imported/exported, and organized by brand, material, and region for rapid reuse and consistency across estimates.
Implement a rules engine that automatically includes, excludes, or swaps components within an assembly based on roof attributes (slope thresholds, story count, facet exposure), selected materials, climate zone, and local code requirements. Support IF/THEN logic, numerical thresholds, per-facet vs whole-roof evaluation, and default fallbacks. Expose user-visible toggles for ambiguous cases (e.g., ridge vent vs. box vents) with sensible defaults. Validate rules at design time and at runtime to prevent conflicts or missing mandatory components.
Integrate a location-aware rule library keyed by ZIP/postcode and jurisdiction to enforce code-driven requirements (e.g., ice-and-water shield coverage from eaves, underlayment type by slope, drip edge mandatory on eaves/rakes). Map components to supplier-specific SKUs, packaging sizes, coverage rates, and availability. Allow selection of a supplier profile per job, with pricing and packaging applied to assembly calculations. Provide graceful fallbacks when a rule or SKU is unavailable and surface warnings for user review.
Enable a single action to expand a selected assembly into fully quantified line items with units, pricing, and prewritten notes, computed from RoofLens measurements and applied rules. Handle multi-facet roofs, multiple slopes, hips/ridges/valleys, penetrations, and waste/rounding logic. Insert the generated items into the estimate and render a ready-to-send PDF scope. Provide a real-time preview and complete operation within 2 seconds for typical jobs, with progress feedback and graceful error handling for edge cases.
Attach standardized, organization-approved notes to components and assemblies using tokenized templates (e.g., {manufacturer}, {slope}, {coverage_area}) that resolve from selections and measurements. Auto-insert notes into line items and final PDFs to ensure clear scope descriptions and reduce disputes. Support multi-language variants, formatting controls, and per-customer or per-carrier note sets to meet documentation standards.
Allow users to override calculated quantities, waste percentages, component toggles, and SKU selections after expansion while clearly indicating deviations from calculated values. Record user, timestamp, and reason for each override, enable revert-to-calculated, and surface validation warnings when overrides risk code noncompliance. Provide optional PDF indicators for overridden lines to maintain transparency with customers and carriers.
Provide versioned assembly templates with draft, review, and publish states. Enable role-based access (admin/estimator/viewer), organization-wide libraries, and personal workspaces. Offer change logs and side-by-side diffs between template versions, with the ability to migrate existing estimates to a newer version and preview impacts before applying to active jobs.
Runs a readiness check before Xactimate export: code completeness, required photo attachments, note compliance, grouping/order, and carrier‑specific formatting. Fix issues in one click, then output a clean ESX/CSV or send via API—ensuring imports load cleanly with minimal edits.
Configurable profiles for carriers and TPAs specifying required line-item codes, grouping and ordering, tax and waste handling, naming conventions, photo and note requirements, and ESX/CSV export formatting. The preflight engine selects a profile per job (manual selection or auto-detected from claim metadata) and applies it to validate, normalize, and format the estimate accordingly. Includes versioning, effective dates, and regional variations to accommodate changing rules. Integrates with RoofLens’ estimate builder, pricing region settings, and export services to ensure Xactimate imports match carrier expectations with minimal edits and reduced rejections.
Automated validation that scans all estimate line items for missing or invalid Xactimate codes, unit types, quantities, pricing region/date, waste factors, tax settings, and required attributes. Flags duplicates, incompatible combinations, and ungrouped items; enforces grouping and order by trade/room per active carrier profile. Presents actionable, line-referenced messages and auto-suggests correct codes and prices using RoofLens’ code library and pricing API. Ensures generated ESX/CSV contains complete, consistent data for clean import with minimal post-editing.
Validation of required photo evidence and documentation against the active carrier profile, including elevation overviews, damage close-ups, annotated images, and measurement references. Checks image labeling, association to elevations/slopes, EXIF timestamps, and minimum photo counts and angles. Supports auto-attach from RoofLens photo sets and drag-and-drop additions. Applies severity policies to block export on critical gaps or warn on advisories. Improves documentation completeness to reduce disputes and rejections during carrier review.
Analysis of line-item, room, and summary notes to enforce carrier-required disclaimers, cause-of-loss statements, measurement references, and prohibited terms. Provides macro templates, inline suggestions, and minimum-detail checks (e.g., slope, material, quantities) while supporting redaction of sensitive data. Generates pass/fail results with suggested edits and quick-insert options to achieve compliance prior to export. Reduces back-and-forth and increases first-pass acceptance.
Automated remediation that applies system-recommended fixes to common preflight issues: mapping to standard Xactimate codes, auto-grouping and ordering items, defaulting missing fields (trade, tax, waste), relabeling photos, and inserting required notes/disclaimers. Presents a change summary with granular accept/reject controls, versioning, and undo. Re-runs validations after application to confirm a clean state. Accelerates export readiness and reduces manual editing time.
A simulated ESX/CSV generation that predicts Xactimate import warnings and errors before producing final files or sending via API. Displays a prioritized checklist with severity levels, line references, and deep links to problem areas, along with suggested fixes or auto-fix options. Supports gating rules to block export on critical issues and allow warnings with acknowledgment. Shortens feedback loops and prevents failed imports.
Direct transmission of validated estimates to Xactimate or third-party intake endpoints via secure APIs using OAuth/API keys, with retries, idempotency keys, and delivery receipts. Supports secure attachment upload, metadata mapping, and webhook callbacks for status updates. Provides a fallback to ESX/CSV download when APIs are unavailable. Records a full audit log of transmissions and outcomes. Streamlines delivery and provides confirmation without manual uploads.
Centrally controlled estimate templates with versioning, one‑click rollouts, and safe rollback. Push updates across branches on a schedule, auto‑migrate in‑flight bids with a clear change diff, and lock critical sections to stop local edits. Ensures every office quotes the same assemblies, notes, and structure—cutting rework and protecting margins.
Provide semantic versioning for estimate templates with immutable released versions and editable drafts. Each release includes auto-generated changelogs, manual release notes, and a visual diff against prior versions (assemblies, line items, pricing formulas, notes, and structure). Prevent direct edits to released versions; require new drafts for changes. Enable quick lookup of which template version was used on any bid and support compare/restore of historical versions. Integrates with RoofLens’ estimate engine and PDF export so generated bids reference the exact template version and metadata.
Enable atomic deployment of a selected template version to chosen branches/teams via a single action, with pre-flight validation (schema checks, pricing formula tests, required fields) and dry-run reporting. Support instant safe rollback to the previously active version, preserving state and documenting reason codes. Handle partial failures gracefully with retry and per-branch status reporting. Integrates with permissions, notifications, and audit logging to ensure controlled, consistent rollouts platform-wide.
Allow administrators to schedule template rollouts for a future date/time with branch-aware time zones, optional blackout windows, and phased waves. Provide pre-rollout notifications and reminders, plus pause/resume controls during execution. Include calendar views and ICS export to coordinate with field teams. Scheduling respects branch dependencies and prevents overlapping deployments that could impact active estimating sessions.
Detect open/in-progress bids impacted by a template update and auto-map changes (added/removed/renamed line items, adjusted assemblies, pricing formula updates). Present a clear side-by-side diff with impact to totals, taxes, and markups, offering accept-all, selective apply, or manual remap options. Support idempotent migrations and record migration notes on the bid. Ensure no data loss with rollback to pre-migration snapshot. Integrates with PDF regeneration and activity timeline so recipients see the updated estimate version.
Provide granular locks on critical template sections (assemblies, cost catalogs, pricing formulas, disclaimers, scope notes, tax/markup rules) to block local edits. Configure role-based permissions and branch-level policies for read-only, editable, or request-override with approval. Enforce locks at UI and API layers, with clear indicators and rationale. Temporary overrides require approver authorization and are time-bound with automatic reversion. Prevents margin erosion and ensures consistent legal/technical language across offices.
Model organizational hierarchy (company → region → branch) with inheritance and scoped overrides. Let admins target rollouts to levels with options to include/exclude children, require local acknowledgment, or force apply. Support regional variables (e.g., tax rates, material availability) as parameters separate from locked content. Define conflict resolution precedence and guardrails to prevent local overrides of locked sections. Visibility tools show effective template at each branch and pending changes.
Capture a complete, immutable audit trail for template edits, approvals, rollouts, rollbacks, migrations, and lock changes with who, when, what changed, and why. Provide configurable approval workflows (single/multi-step) with SLA timers and escalation. Generate exportable logs (CSV/JSON/PDF) and signed snapshots for insurer and partner audits. Surface per-bid provenance showing template version, migration actions, and approvers. Retain records per data retention policy with secure storage and access controls.
Configurable approver workflows driven by role, dollar thresholds, margin floors, and exception types. Auto‑route bids for sign‑off, set SLAs, and approve/decline from web or mobile with reason codes. Keeps deals moving without email ping‑pong while guaranteeing that discounts and scope changes get the right eyes before sending.
Provide an admin UI to define approval rules driven by roles, deal amount thresholds, gross margin floors, discount percentages, line‑item exceptions, customer segment, region, and job type. Rules support condition operators, priority order, effective dates, versioning, and sandbox testing. On bid creation or update, the engine evaluates the estimate data and produces the required approver list and sequence. Ensures consistent governance, reduces errors, and automates routing while integrating with the pricing/estimate models and organization settings.
Continuously detect policy exceptions such as margin below floor, discount beyond threshold, non-standard SKUs, manual line‑item overrides, or scope changes after approval. Highlight exceptions on the bid, block send until required approvals complete, and automatically generate or refresh the approval path. Integrates with the estimate engine to compute margins and deltas, tracking changes across revisions to determine when re‑approval is necessary.
Enable approvers to approve, decline, or request changes from both web and mobile experiences with mandatory reason codes, optional comments, and attachments. Provide deep‑linked notifications to the exact approval item, display key bid context, and enforce justification collection for declines or overrides. Actions update bid status in real time, notify submitters, and are securely recorded for audit. Supports SSO auth and role‑based permissions.
Support serial and parallel approval stages with flexible completion rules (any‑one‑of, all‑of, n‑of‑m) and conditional branching based on bid attributes. Prevent sending until all required stages finish, and require re‑approval when protected fields change. Allow step-specific instructions and visibility controls so participants see only what they need. Works with rule engine outputs to generate the precise path per bid.
Allow per‑step SLA definitions with business hours and holiday calendars, send timed reminders to approvers, and auto‑escalate to designated alternates or managers when deadlines are missed. Provide pause/resume controls when bids are on hold, and surface countdowns and overdue indicators in queues. Capture SLA compliance metrics for reporting and continuous improvement.
Maintain an immutable audit log of approval events including user, role, timestamp, decision, reason code, and comments. Expose the log within the bid, export it as a report, and embed a summary section into the final PDF bid package. Link each approval to the exact bid version to show what changed between submissions. Enforce retention policies and provide searchable history for compliance and dispute resolution.
Allow approvers to set time‑bound delegates and out‑of‑office rules, with admin overrides for coverage. Auto‑route steps to delegates during the defined window, notify both primary and delegate, and record delegated decisions in the audit trail. Prevent self‑approval and enforce separation of duties where configured. Provide visibility into active delegations in the approval path preview.
Define allowed ranges for waste factors, labor hours, line‑item quantities, and discounts by roof type and market. Soft warnings request justification; hard stops prevent risky submissions. Color‑coded guidance and inline suggestions help estimators stay compliant without slowing them down.
Provide an administrative interface to define and manage allowed ranges for waste factors, labor hours, line‑item quantities, and discounts. Support scoping by roof type, market, and customer segment; specify min/max thresholds, defaults, and enforcement type (soft warning vs hard stop). Include versioning with effective/expiration dates, preview of impacted SKUs/rules before publish, RBAC-controlled access, bulk import/export (CSV), change history, and rollback. Ensure validation of rule integrity (no overlapping effective windows without precedence), and surface a read-only preview of active rules to estimators.
Implement a rules resolution service that determines which variance bands apply to an estimate based on project context (roof type, market, insurer/program, date). Handle precedence, inheritance from global defaults, and graceful fallbacks when context data is incomplete. Normalize units and parameter types, compute derived limits (e.g., aggregate waste %), and cache resolved bands per estimate for performance. Re-resolve bands on context change and expose a deterministic explanation trace for transparency and debugging.
Validate estimator inputs against active variance bands on field change and on submission. Trigger soft warnings that allow continuation only after justification capture, and hard stops that block submission, PDF generation, and external exports until resolved. Support per-line-item and aggregate checks, clear inline messaging, and structured validation results consumable by UI and API clients. Ensure low-latency feedback, debounced evaluation, and resilient behavior offline with queued validations syncing on reconnect.
Provide a guided flow to capture justifications for soft-warning variances, including required reason codes, free-text notes, and optional photo/document attachments. Enable configurable approval thresholds and routing to managers, with notifications, SLAs, and reminder escalations. Allow approvers to approve/deny with comments; unblock submission upon approval; and record all actions in an immutable log. Support mobile-friendly input, draft saving, and re-use of common justification templates.
Enhance the estimate UI with accessible color coding (green within band, amber near thresholds, red out-of-band) and tooltips showing allowed ranges and rationale. Offer inline suggestions derived from roof geometry, historical estimator performance, and market norms, with one-click apply and quick-revert. Ensure WCAG 2.1 AA compliance, keyboard navigation, and user preferences to toggle hints. Provide a compact summary panel listing current variances and suggested fixes.
Capture comprehensive event logs for variance evaluations, warnings, hard stops, justifications, approvals, and overrides with timestamps, users, rule versions, and context. Provide dashboards and filterable reports by market, roof type, user, and date; KPIs such as out-of-band rate, average approval time, and top offending line items; and export to CSV/PDF. Include data retention settings, PII controls, and the option to embed a compliance summary in generated bid PDFs and through the API.
Expose secure REST endpoints to CRUD variance bands, retrieve resolved bands for a given context, and validate external estimate payloads. Implement OAuth2 scopes, rate limiting, and idempotency. Publish webhooks for rule publish/update/expire events to keep partner systems synchronized. Provide versioned schemas, sandbox environment, and detailed error contracts aligned with internal validation messages.
Live margin tracking with configurable floors and targets. When a bid dips below guardrails, the estimate locks sensitive fields and offers smart fixes—price adjustments, assembly swaps, or alternates—to bring profit back in range. Prevents over‑discounting while preserving deal velocity.
Enable administrators to define and manage margin floors and targets at multiple scopes (account-wide, customer segment, job type, region, product/assembly). Support effective-dated configurations, currency and tax considerations, and role-based visibility/enforcement. Provide a configuration UI with validation, import/export, and API endpoints for programmatic management. Changes propagate instantly to active estimates with safe fallbacks and audit logging.
Compute gross margin in real time at line, section, and total levels using current cost basis (materials, labor, equipment, waste, overhead, fees), applied taxes, and discounts. Update calculations within 200 ms of any edit, with debouncing to minimize flicker. Handle alternates, assemblies, and multi-currency rounding rules. Expose a breakdown panel, tooltips for formula transparency, and a stable API for margin metrics consumed by other components.
Automatically lock configurable pricing fields (e.g., unit price, discount, markup) when the estimate margin falls below the defined floor. Visually indicate locked fields, preserve draft values, and provide contextual explanations with links to allowed actions. Respect role permissions for bypass and log all lock/unlock events. Persist lock state across sessions and ensure parity across web and mobile editors.
Offer guided remediation options when margin breaches occur, including price adjustments (e.g., increase by X to hit target), assembly swaps to higher-margin equivalents, and presenting customer-facing alternates. Simulate outcomes before apply, display expected margin impact deltas, and allow one-click application with undo. Leverage catalog data and rules to ensure compatible substitutions. Track chosen suggestions and effectiveness for continuous improvement.
Provide a request/approve mechanism for exceptions below margin floors, capturing reason codes and notes. Support tiered approvers based on deal size, customer segment, and variance from floor, with SLA timers, notifications, and mobile/email approvals. On approval, temporarily unlock relevant fields and allow bid progression; on rejection, maintain locks and suggest alternatives. Maintain a complete audit trail and integrate with CRM for approval status sync.
Enforce margin compliance at key milestones by blocking finalization, PDF generation, and external system sync when margin is below floor without an approved override. Provide clear gating messages, read-only preview, and a path to request approval or apply smart fixes. Ensure enforcement via both UI and API to prevent circumvention. Optionally annotate generated PDFs with margin status metadata or watermark for internal use.
Capture detailed telemetry on margin events, including frequency and duration of breaches, fixes applied, recovery rates, approvals, and user actions. Provide dashboards and exports segmented by rep, team, product, region, and time, with filters and KPI benchmarks. Support data governance (retention windows, PII minimization) and role-based access. Expose a data feed to BI tools for advanced analysis.
Market‑specific guardrails packaged into reusable profiles: permitted materials, code‑required adds, crew rates, taxes, and carrier preferences by ZIP/county. Auto‑apply on job creation so branches inherit the right rules by default—speeding setup and eliminating regional inconsistencies.
Automatically detect the job’s ZIP/county from the entered service address and apply the highest-precedence matching Region Profile at job creation. The applied profile sets default permitted materials, code-required adders, crew labor rates, taxes, waste/overhead rules, and carrier preferences for the job’s estimate. Implement deterministic precedence (job-specific override > branch default > ZIP > county > state > global) with clear fallback behavior when mappings are missing or ambiguous, including user alerts and a selectable resolution flow. Provide a “Reapply Profile” action that safely reapplies current profile rules while preserving user overrides according to configurable conflict policies (e.g., warn, merge, replace). Ensure idempotency, audit logging of applied profile and parameters, and compatibility with downstream estimate generation and PDF outputs.
Define a normalized Region Profile entity that captures jurisdiction scope (ZIPs, counties, states), effective start/end dates, semantic version, and rule bundles: permitted materials and substitutions, code-required line items with conditional triggers (e.g., pitch, deck type, climate zone), crew labor rates, tax schema, waste factors, overhead/profit, and carrier-specific preferences. Support inclusion/exclusion lists, inheritance from base templates, and precedence resolution for overlapping jurisdictions. Maintain authoritative identifiers (FIPS, USPS ZIP, state codes) and many-to-many mappings to support ZIPs spanning multiple counties. Expose the model via internal APIs with validation, referential integrity, and migration scripts for safe evolution.
Integrate Region Profile rules into the estimate builder to enforce permitted materials and automatically insert code-required adders when trigger conditions are met. Provide inline validations and contextual warnings for disallowed items, with role-gated override capabilities requiring justification. Apply profile-driven crew rates, taxes, waste, and carrier preferences to all line-item and total calculations. Display provenance (which rule triggered which change) and maintain an audit trail of all enforcement and overrides. Ensure the enforcement engine is performant, testable, and works consistently across web UI, API-driven estimate creation, and PDF generation.
Provide an admin console to create, edit, clone, import/export, and archive Region Profiles with draft/publish workflows and effective dates. Enable bulk assignment of ZIPs/counties via CSV and an interactive map picker with validation against USPS and FIPS datasets. Offer starter templates for common markets (e.g., hurricane, hail, cold-weather codes) that prefill guardrails. Include change history with side-by-side diffs, impact previews (branches/jobs affected), and publish scheduling. Enforce RBAC so only authorized roles can publish or retire profiles, with notifications to affected branches upon changes.
Allow organization and branch admins to assign default Region Profiles per branch and optionally per carrier. Enable job-level profile overrides based on role permissions, with mandatory reason capture and automatic audit logging (who, when, from/to, reason). Surface override indicators in the job header and estimates. Provide reporting on override frequency, top reasons, and financial impact to guide governance and training. Ensure API parity for setting and querying defaults and overrides.
Implement scheduled ingestion and normalization of authoritative ZIP/county/state datasets (USPS, Census/FIPS), handling ZIPs spanning multiple counties and boundary updates. Provide a geo lookup service that resolves a job address to the most specific applicable jurisdiction, with caching, retries, and graceful degradation when third-party services are unavailable. Detect coverage changes that alter which profiles apply and notify admins with suggested updates. Expose health metrics and alerts for data freshness and lookup error rates.
Support semantic versioning and lifecycle states (draft, published, retired) for Region Profiles with effective start/end dates. Ensure jobs created after the effective date automatically use the latest version, while existing jobs remain stable unless explicitly migrated. Provide a migration tool that previews diffs (rates, materials, adders, taxes), estimates impact on totals, and applies changes with full audit logging. Emit events/webhooks on publish and migration for downstream integrations and branch notifications.
Real‑time dashboard and alerts tracking template drift, override frequency, approval latency, and branch margin variance. Drill into outliers, export audit packs, and send weekly scorecards to managers. Surfaces risk before it hits the bottom line and drives continuous improvement across the franchise.
Implement a real-time data pipeline to ingest estimating events, template selections, overrides, approvals, and job outcomes, then compute template drift, override frequency, approval latency, and branch margin variance within 60 seconds of occurrence. Maintain baselines by branch, template version, carrier, job type, and rolling window, with seasonality adjustments and backfill for historical comparisons. Ensure idempotent processing, data quality validation, and late-event handling. Store time-series metrics and aggregates optimized for dashboard queries and alerts, and expose an API for the dashboard and alert engine to consume.
Provide a configurable rules engine to define alert thresholds and conditions per metric (drift %, override frequency, approval latency SLA breaches, margin variance). Support absolute and percentage thresholds, rolling windows, branch/template scoping, hysteresis to reduce noise, suppression windows, and schedules. Implement routing to managers based on org hierarchy and channels (in‑app, email, SMS), with escalation and deduplication. Log alert lifecycle (triggered, acknowledged, resolved) for auditability and performance review.
Create interactive dashboard widgets with drill‑down into outliers by branch, estimator, template, carrier, job type, and timeframe. Enable click‑through from an alert to a pre‑filtered investigation view showing contributing jobs, change history, overrides applied, approval steps with timestamps, and comparisons to baseline and peers. Provide contextual KPIs, sparkline trends, and exportable tables (CSV) for offline analysis. Optimize queries for sub‑second filtering and paging on large datasets.
Generate automated weekly scorecards per branch and region summarizing drift, override rates, approval latency, and margin variance trends, including rankings versus peers and week‑over‑week changes. Support distribution list management, time‑zone aware scheduling, PDF attachment generation, and links to the live dashboard. Include delivery retries, failure notifications, and a digest mode that bundles multiple branches for a manager. Archive sent scorecards for audit and historical reference.
Enable one‑click export of audit packs for selected periods, branches, or alerts containing flagged estimates, change logs, approval timestamps, template versions used, override details, manager comments, and supporting screenshots or attachments. Produce a ZIP with an index, metadata manifest, and checksums for integrity. Store immutable evidence snapshots with configurable retention (up to 7 years) and optional WORM storage. Provide export watermarking, access logging, and download expiration for compliance.
Calculate margin variance versus configurable benchmarks by region, branch, job type, and season, with control charts to detect sustained variance beyond control limits. Allow exclusion filters for promotional periods or extraordinary events and annotate charts with known drivers. Surface leading indicators and contributor analysis (template changes, frequent overrides, estimator mix) to guide corrective actions. Expose APIs for finance systems to pull benchmarked metrics.
Implement RBAC and data scoping for Compliance Pulse, restricting visibility by role (estimator, manager, compliance, finance) and organizational unit (branch, region). Enforce field‑level masking for sensitive data in dashboards and exports, and require elevated permissions for audit pack downloads. Record comprehensive access and export logs, with anomaly detection for unusual access patterns. Integrate with existing SSO/IdP groups and support SCIM provisioning for automated user management.
Central console to issue WebAuthn passkeys and scannable crew badges with role scopes, branch restrictions, and expirations. Supports bulk provisioning, print‑ready QR/NFC, instant revoke, and live status. Cuts IT overhead while enforcing least‑privilege access for field uploads.
Implement end-to-end WebAuthn registration and authentication ceremonies to issue passkeys bound to user accounts and physical authenticators (platform and cross‑platform). Support attestation, resident/non‑resident keys, UV/PIN policies, credential backup/duplication flags, and origin restrictions tied to RoofLens console and field uploader surfaces. Persist public key credentials and metadata mapped to badge identities and enforce lifecycle operations (create, rotate, rebind, delete) with admin approval workflows and recovery options. Integrate with existing auth to mint session tokens limited by badge role scope, branch restrictions, and expiration. Provide telemetry on success/failure, device type, and risk signals for policy decisions.
Deliver a centralized policy model to express least‑privilege access using role scopes (e.g., Field Uploader, Estimator, Adjuster), branch restrictions (office/region/site), and time‑bound expirations. Enforce policies consistently across API endpoints (upload, job access, estimate export) and UI components via middleware and attribute‑based checks. Support object‑level constraints (upload‑only, no pricing view), policy versioning, and atomic updates with rollback. Provide reusable evaluators for synchronous checks at request time and for token minting (claims embedding policy digests). Supply admin UX for assigning scopes during provisioning and REST/GraphQL APIs for automation.
Generate secure, scannable crew badges with templated layouts (name, role, branch, expiration, serial) exportable as print‑ready PDF and digital PNG/SVG. Encode QR with short‑lived signed tokens or verification URLs and program NFC tags with NDEF payloads that reference the same token scheme. Provide design presets and custom branding, plus batch rendering for bulk runs. Avoid storing excessive PII on the badge; rely on cryptographic verification server‑side. Integrate with supported NFC encoders and printers, and link each badge to its WebAuthn credential and policy profile for unified lifecycle management.
Enable mass onboarding through CSV upload and programmatic APIs. Provide column mapping for user identity, role scope, branch, expiration, and notification preferences; validate inputs with inline error messaging and downloadable error reports. Offer dry‑run previews, idempotency keys for safe retries, and rate limits. Trigger enrollment notifications with self‑serve passkey registration links and optional manager approvals. Expose webhooks for downstream HRIS/IdP sync and support de‑duplication against existing users/badges. Maintain full audit trails for each imported record and resultant actions.
Provide immediate revocation and suspension of badges and associated passkeys with propagation to token introspection, upload endpoints, and verification flows. Implement automatic expiration with configurable grace windows and notifications before/after expiry. Push revocation signals to caches and edge locations; include anti‑replay via nonce tracking and token rotation. Support bulk revoke for crews, branches, or imports, and expose APIs for SIEM/incident response integrations. Display clear state changes in the console and prevent new sessions while cleanly terminating active ones.
Build a real‑time dashboard listing badges and passkeys with status (active/suspended/revoked/expired), last activity, branch, role, and expiration. Include powerful filters, exports, and drill‑downs to individual events. Capture a tamper‑evident audit log of issuance, scans, verifications, uploads, policy changes, and administrative actions, with retention and privacy controls. Stream live updates via WebSockets/SSE and surface alerts for anomalies (excessive failures, out‑of‑region scans). Provide evidence packages for disputes, including signed log excerpts and hash chains for integrity verification.
Offer a public verification endpoint that validates QR/NFC tokens, checks policy/expiration/revocation, and returns minimally scoped directives (e.g., upload permissions for a job/branch). Deliver a mobile‑friendly scan experience with deep links into the RoofLens Field Uploader. Support offline verification via short‑lived signed tokens with embedded policy digests and CRL/denylist stamps, with automatic refresh when connectivity returns. Include rate limiting, anti‑replay, and device fingerprinting to reduce fraud. Provide supervisor mode for on‑site validation and quick troubleshooting of denied scans.
Bind badges to approved devices with hardware attestation and OS integrity checks. Uploads require a verified badge+device pair, blocking rooted/emulated devices and flagging anomalies in the Custody Ledger. Prevents spoofed photos and impersonation, strengthening evidence defensibility.
Integrate hardware-backed attestation and OS integrity verification on iOS and Android to validate device authenticity prior to enabling sensitive actions. On iOS, leverage App Attest/DeviceCheck; on Android, use Play Integrity API with hardware-backed keys and evaluation types. Detect and score risk signals including jailbreak/root, emulator/virtual device, bootloader unlock, debug builds, and tampered OS. Surface a signed attestation verdict to the backend for every session and sensitive operation, cache short-lived results server-side, and enforce expiry to prevent replay. This requirement establishes the technical foundation that ensures only trustworthy devices can pair with badges and initiate uploads, directly reducing spoofed-photo and impersonation risk while fitting into RoofLens’ secure capture flow.
Provide a guided enrollment flow that registers a device to a user’s badge after successful attestation. Generate and store a stable, privacy-preserving device fingerprint and a hardware-bound public key, then bind these to the badge and organization. Enforce organization-configured limits (e.g., max N devices per badge), require admin approval when limits are exceeded, and record enrollment metadata (time, geo, OS version, app build). Support re-attestation on app launch and periodic key rotation. Persist device-badge bindings in a secure registry to be referenced by policy checks across capture, upload, and account management flows.
Enforce that every photo, video, and telemetry upload includes a fresh, server-validated attestation token tied to the active badge-device pair. Reject uploads when attestation is missing, expired, mismatched, or high-risk. Bind the attestation to the upload payload via nonce and timestamp to prevent replay and cross-session misuse. Expose precise error codes to clients, fail closed by default, and expose policy toggles for org-level strictness (block vs. quarantine). This gate ensures only verified badge+device pairs can contribute evidence to jobs, blocking spoofed or impersonated submissions at the point of entry.
Record all attestation outcomes and policy decisions in the Custody Ledger for each asset. Log device fingerprint hash, badge ID, attestation provider result, risk signals, app build, OS version, time, geo, and action (enrolled, allowed, quarantined, blocked). Link anomalies to the job record and surface them in PDF exports and API so downstream reviewers can audit provenance. Provide searchable filters and an exportable CSV for compliance responses. This creates a durable, auditable chain of custody that strengthens evidence defensibility and accelerates dispute resolution.
Allow users to capture media while offline and queue assets locally in an encrypted store. Require a locally generated hardware-backed signature at capture time, then enforce full server-side attestation before accepting uploads when connectivity returns. Mark assets as “quarantined” until a valid badge-device attestation is verified within a configurable freshness window; expire or require manual review if the window is exceeded. Preserve capture timestamps, coarse location, and device state snapshot to maintain custody continuity even without network access, supporting field work in low-signal job sites without compromising integrity.
Deliver an admin console to review, approve, and revoke device registrations per badge and organization. Show device details (model, OS, last attestation, risk history) and active sessions. Provide immediate and scheduled revocation, require a reason code, and propagate revocation to invalidate tokens, end sessions, and wipe local keys on next check-in. Support bulk actions, CSV import/export, and API endpoints for MDM integrations. Notify affected users and record all admin actions in the Custody Ledger for auditability.
Provide clear, action-oriented in-app messaging for attestation failures and policy blocks. Map error codes to user-friendly explanations and step-by-step remediation (e.g., update OS, disable developer options, relaunch app, contact admin). Include a one-tap retry, an override request flow with justification and photo ID capture, and a support reference code linking to the Custody Ledger entry. Localize strings and respect accessibility guidelines. This reduces friction for legitimate users while maintaining strict enforcement against risky devices.
Time‑boxed, geofenced offline credentials stored in secure hardware let crews scan and upload on sites with no signal. Captures are locally signed with GPS/time and replay protection, then auto‑sync and seal the chain‑of‑custody when back online. Keeps work moving without sacrificing trust.
Issue server-signed, time-boxed and geofenced offline passes bound to job IDs, crew members, and device fingerprints. Passes are delivered to the mobile app and stored using hardware-backed keystores, with device attestation to prevent cloning. Includes pass versioning, automatic expiration, remote revocation, and prefetch of revocation lists for offline checks. Integrates with RoofLens job assignments, roles, and notifications, and logs all lifecycle events for auditability.
Generate a per-device keypair in Secure Enclave/StrongBox on first run and bind passes to the device public key. Each offline capture bundle is signed locally over a content hash, pass ID, job ID, GPS coordinates, timestamp, and a monotonic sequence number with per-capture nonce for replay protection. Package captures in a tamper-evident container that also records OS version, app version, and limited device attestation signals. No private keys leave hardware; signing APIs fail closed if hardware protections are unavailable.
Enforce pass geofence and validity window entirely on-device with coarse-to-fine location checks, hysteresis to handle GPS drift, and user feedback when out-of-bounds or expired. Cache minimal map data and geofence polygons for offline validation and provide a countdown to expiry. Block capture initiation when policies are violated and record reason codes for later audit. Operates efficiently to minimize battery usage and respects platform location permission models.
Store photos, notes, and measurement artifacts in an encrypted offline queue tied to hardware-backed keys. Support resumable, chunked uploads with exponential backoff, duplicate suppression via content hashes, and ordering by pass sequence number. Auto-detect connectivity and policy (Wi‑Fi only, data saver) to trigger background sync, with clear progress indicators and failure reasons. Integrates with RoofLens job submission to ensure captures attach to the correct job upon sync.
On sync, verify pass signatures, device-bound keys, geofence compliance, timebox validity, and replay protections (nonce and sequence). Create an immutable audit record linking capture bundles to job IDs, pass IDs, and device IDs, and attach a verification report to the job. Surface verification status in the web app and embed chain-of-custody metadata into generated PDFs and API responses. Route failed verifications to a review queue with granular reason codes and recommended remedies.
Provide a web console to create passes with geofence polygons and validity windows, assign them to crews and devices, view real-time pass status, and revoke individually or in bulk. Offer CSV export, webhooks, and email/SMS alerts for upcoming expirations, out-of-bounds attempts, and repeated sync failures. Enforce role-based access control and maintain an audit log of all administrative actions. Expose APIs for partner integrations to automate pass provisioning from scheduling systems.
Deliver clear in-app indicators for offline status, pass validity, geofence proximity, and remaining time. Include an offline preflight checklist that syncs time, downloads geofence data, and caches required assets before leaving coverage. Provide actionable error messages, low-storage warnings, and a safe shutdown that flushes the queue to persistent storage. Present a crew-facing session summary for sign-off and support accessibility and localization requirements.
After a badge scan, geofence verification auto‑selects the correct job, assigns the uploader role, and locks uploads to that file. Preloads flight presets and checklists so capture starts immediately. Eliminates misfiled photos and speeds on‑site kickoff.
Enable users to initiate a secure on-site session by scanning a company-issued badge (NFC/QR). Validate identity against the organization directory and SSO, issue a time-bound session token, and register device metadata. On success, preload minimal user profile, role entitlements, and organization context for subsequent steps. Provide graceful failure states (e.g., expired badge, unknown user) with actionable prompts. Enforce session timeout and re-authentication policies aligned with security standards.
Use high-accuracy location services to verify presence within predefined site geofences and automatically select the correct job record. Apply accuracy thresholds and dwell-time rules to reduce false positives, and implement tie-breakers when multiple jobs overlap (nearest centroid, start time proximity, crew assignment). Provide a fallback selector if no confident match is found and log all decision criteria for auditing. Syncs with scheduling/CRM to fetch upcoming jobs and geofence boundaries.
Upon successful geofence verification, automatically assign the user the appropriate on-site role (e.g., Uploader) for the selected job and enforce least-privilege permissions. Lock restricted actions (e.g., changing job context, deleting media) during the on-site session. Support supervisor overrides and escalation rules, and automatically revoke elevated rights on session end or geofence exit. Integrate with the platform’s RBAC service and reflect role state in the UI.
Bind all captured media (photos, videos, thermal, notes) to the auto-selected job ID and prevent cross-job misfiling. Tag each asset with immutable metadata (job ID, timestamps, GPS, device, operator) at capture time, queue securely on-device, and sync to the correct job file. Provide visibility into the current binding state and block uploads to other jobs unless an authorized override is granted, which must be audited.
Automatically preload drone flight presets (altitude, overlaps, patterns, camera settings) and safety/compliance checklists based on client, roof type, and jurisdiction once the job is selected. Push presets to supported drone SDKs and require completion of critical checklist items before flight arming. Allow admins to manage versioned templates and per-client overrides, and cache presets for quick startup. Record checklist results with timestamps and operator identity.
Ensure core Site Auto‑Claim flows function with limited or no connectivity. Cache upcoming jobs, geofences, user entitlements, presets, and checklists for the day. Allow offline badge validation via signed tokens or last-known trust window, capture and locally encrypt assets, and queue metadata and logs for later sync. Provide clear offline/online indicators, conflict resolution policies, and automatic retry with exponential backoff once connectivity returns.
Capture a tamper-evident timeline of on-site events including badge scan, geofence fixes, job selection rationale, role assignment, checklist completion, flight start/stop, and upload bindings. Store with timestamps, user, device, and location metadata; expose the timeline in the job file and allow export for dispute resolution. Enforce retention policies and integrity checks, and surface anomalies (e.g., geofence mismatch) to admins.
Real‑time presence and shift timeline powered by first/last scan events show who’s on site, for how long, and in what role. Managers get alerts for no‑shows and early departures, while SLA forecasts improve with verified field presence. Export attendance for compliance and payroll.
A live, auto-refreshing dashboard that shows who is currently on each job site, their role, check-in status, and time on site. Data updates sub-minute via WebSockets/SSE with a polling fallback. Users can filter by job, crew, role, and shift date, and view presence badges (on-time, late, no-scan). Integrates with RoofLens job sites and crew assignments, honors RBAC permissions, and logs an auditable trail of presence changes.
Reliable ingestion and processing of check-in/out events from mobile scans (QR/NFC), manual confirmations, and third-party timeclocks. Supports offline buffering with backfill, idempotent event handling, geofence validation, timestamp normalization with time zones, and deduplication. Associates events to users, roles, jobs, and shifts to derive presence states and durations for the timeline.
An interactive timeline that visualizes each person’s shift segments per job, derived from first/last scan events, breaks, and role changes. Supports anomaly flags (missing checkout, overlapping shifts), reason-coded adjustments with permissions, and a complete audit log. Syncs with project schedules and weather holds to distinguish excused gaps from no-shows and exports as PDF for client or compliance review.
Configurable alert rules by job, crew, or user to detect missed check-ins, late arrivals, and early departures against scheduled shifts. Sends push, SMS, and email notifications with escalation, quiet hours, and snooze controls. Suppresses alerts for approved delays (e.g., weather), links directly to the timeline for context, and exposes webhooks for external workforce systems.
Geo-verified check-ins confined to job site geofences with configurable radius and anti-spoofing checks (GPS integrity, device fingerprint, optional selfie). Provides exception workflows requiring supervisor approval and reason codes. Visualizes geofences on the map, supports multi-site projects, and ties verified presence to SLA and payroll calculations.
One-click exports of approved attendance data in CSV, XLSX, and PDF with job codes, roles, overtime, breaks, and approval status. Schedules recurring deliveries via email or SFTP and offers an API endpoint. Supports locale-specific rules (daily/weekly overtime), customer-specific column mappings, and connectors for ADP, Gusto, and QuickBooks Time with audit metadata included.
Forecasts SLA adherence using real-time presence and historical crew-hour trends versus plan. Highlights under-staffed intervals, predicts risk to milestones, and recommends staffing adjustments. Incorporates weather data and job complexity tags to refine projections and surfaces confidence bands on the timeline and in downloadable reports.
Role‑based safety and compliance checklists (Part 107, PPE, access permission) are signed with the user’s passkey at scan. Non‑compliant steps trigger guidance or require a supervisor override. Attestations attach to the job and Custody Ledger, reducing risk and audit friction.
Provides configurable, standards-aligned checklists that adapt by user role (pilot in command, visual observer, supervisor), account policies, job type, and location. Supports FAA Part 107 items, PPE verification, property access permissions, and custom organization-specific items. Includes conditional logic, required/optional flags, versioning with effective dates, localization, and mobile-friendly UI with offline capability. Integrates with RoofLens job context to prefill known fields (job address, client, permit), records per-item responses, evidence attachments (photos, files), timestamps, and geolocation. Ensures repeatable, auditable preflight processes that reduce risk and speed on-site setup.
Requires users to sign completed preflight checklists using platform-supported passkeys (WebAuthn/FIDO2) with device biometrics, binding the attestation to their verified identity. Captures and stores a signed payload including user ID, role, job ID, checklist version, per-item outcomes, timestamp, device info, and GPS fix. Performs server-side signature verification, prevents replay, and flags discrepancies. Provides graceful fallback when passkeys are unavailable (admin-configurable) while maintaining an audit trail. Enhances non-repudiation and downstream audit confidence.
Automatically evaluates checklist responses against FAA Part 107 rules and account policies in real time, including controlled airspace requirements (LAANC), daylight/twilight restrictions, weather minima, NOTAMs/TFRs, battery health, and site access authorization. Provides inline guidance to remediate issues, blocks job start and image capture when critical items are non-compliant, and enables read-only access to capture modules until cleared. Supports offline prechecks with cached advisories and queues validations for sync when back online. Admin toggles allow integrations for airspace/weather providers and policy thresholds.
Implements a structured override process for non-compliant checklist items, requiring supervisor selection, reason codes, risk acknowledgment text, and passkey signature from the approver. Supports time-bound and scope-limited overrides (single job, single flight, or duration), captures communication notes, and attaches all artifacts to the attestation. Triggers notifications for overrides and auto-creates follow-up tasks for post-incident review. Ensures exceptions are controlled, documented, and audit-ready.
Automatically attaches the signed attestation, evidence, and validation results to the RoofLens job record and writes an immutable digest to the Custody Ledger. Generates verifiable artifacts (PDF and JSON) with checksum and QR code for third-party verification without platform access. Exposes API endpoints and webhooks for insurers/customers to retrieve attestations, and enforces data retention policies with legal hold support. Provides a timeline view within the job showing who did what and when.
Enables field users to initiate the preflight attest process by scanning a job QR code or tapping NFC at the site. Auto-loads the correct job, applies a geofence to confirm location, pre-populates known details, and launches the role-appropriate checklist. Supports offline caching of assigned jobs and secure sync when connectivity resumes. Minimizes tap count and reduces mismatch errors between field work and back-office records.
Sends real-time notifications to designated supervisors when a checklist is blocked, when an override is requested, or when required attestations are overdue. Supports push, SMS, email, and Slack/MS Teams, configurable quiet hours, and escalation chains with SLAs. Logs all notifications in the job timeline and links to the specific non-compliant item for quick action. Provides an admin dashboard to monitor outstanding blocks and override volume.
Sponsor‑approved, single‑job guest badges for subs, adjusters, or auditors with capture‑only rights, export limits, and automatic expiration. Images carry visible guest identity watermarks and full traceability. Enables secure collaboration without sharing accounts or expanding licenses.
Provides a sponsor-driven workflow to create, configure, and deliver guest passes for a single job. Sponsors select the job, set expiration date/time, define capture-only permissions, and configure export limits. The system generates a unique, scoped invite delivered via email/SMS with one-time passcode (OTP) verification; no full account is required. The flow records invite creation, acceptance, and terms consent; supports resend, revoke, and reissue actions. Integrates with RoofLens Jobs so guests land directly in the assigned job context, and enforces configuration across web and mobile capture experiences. All actions are written to the job’s audit trail for compliance.
Ensures each guest pass is cryptographically bound to a single job_id, restricting UI navigation and API access to only that job’s assets and tasks. Removes global project lists, search, and cross-job navigation for guests. Validates job scope on every request server-side, blocks attempts to access other jobs, and returns sanitized errors. Optionally supports geofencing to the job address polygon for added assurance. Includes automated tests for scope checks and monitoring alerts for cross-scope access attempts.
Implements a permission profile that limits guests to media capture and upload only. Disables measurement generation, editing, deletion, export, pricing, and sharing actions in UI; enforces the same restrictions via API authorization. Guides guests with contextual UI (e.g., disabled buttons with tooltips) and a streamlined capture screen. Supports background uploads, queued retries, and network-resilient transfers while preventing any data exfiltration paths. Sponsors can optionally enable limited annotations that do not alter measurements. All captured items are auto-associated with the job and the guest’s identity.
Applies visible, non-removable watermarks to all guest-captured images and videos showing guest name, organization, date/time, job ID, and pass ID. Uses diagonal tiling plus edge seals to deter cropping. Embeds matching IPTC/XMP metadata and cryptographic hash references for tamper detection. Stores an original master for internal processing but serves only watermarked derivatives in all guest-visible views and any sponsor-initiated exports that include guest media. Watermark styles adapt to light/dark imagery for legibility. All watermark and metadata parameters are recorded to the audit log.
Enforces configurable export rules per guest pass, including hard disable, file-type restrictions, resolution caps, daily/total quotas, and watermark-only derivatives. All export attempts are authorized server-side against pass policy and logged. Provides clear UI messaging to guests when exports are limited or blocked. Sponsors can override or extend quotas in real time. Integrates with existing PDF bid and media export pipelines to ensure guest media always carries watermarks and policy-compliant transformations.
Defines a required expiration for each guest pass with automatic revocation at expiry. Tokens and sessions are invalidated server-side; guests are signed out and can no longer upload or view job assets. Provides sponsor controls for immediate revoke and extend, plus optional pre-expiration reminders to both sponsor and guest. Handles partial uploads gracefully at cutoff with clear user feedback. Integrates with job lifecycle (e.g., closes access when job is archived) and includes health checks to prevent stale active passes.
Captures an immutable event log for the entire guest pass lifecycle: creation, invite delivery, OTP verification, login, capture events (with device, OS, IP, GPS where available), uploads, failed attempts, export requests, policy evaluations, revokes, and expiry. Events are linked to job, guest identity, and pass ID. Provides a timeline view in the Job Audit panel and exportable reports (CSV/PDF) for dispute resolution and carrier audits. Supports retention policies and searchable filters to rapidly investigate incidents.
Set hard and soft spend caps by day, week, event, or branch that automatically throttle bulk uploads and require approval when limits are hit. Ties into SLA Predictor and GeoHeat Overlay to prioritize credits for highest‑impact addresses first, protecting budgets during storms without slowing critical jobs.
Enable administrators to configure hard and soft caps on spend, credits, or job counts by day, week, custom event window, and branch. Support inheritance and overrides at organization → region → branch levels, time zone awareness, and automatic reset schedules. Caps apply to key consumption points (bulk uploads, estimate generation, credit usage) and enforce hard stops or soft warnings based on policy. Provide currency configuration, cap preview before activation, and full audit history of policy changes. Integrate with billing/credits and user permissions to ensure only authorized roles can create or modify caps.
Automatically throttle bulk uploads when approaching soft caps and enforce rate limits or pauses at hard caps. Queue incoming jobs with fair-share allocation across branches and provide estimated start times, remaining budget indicators, and reordering based on priority policies. Support pause/resume, cancellation, and per-branch throughput controls to prevent budget overruns during surges while maintaining predictable processing for active jobs.
Require approval when a submission would exceed a soft or hard cap, with configurable rules for who can approve, multi-step approvals, SLA-based auto-approval exceptions, and time-bound approval windows. Provide in-app notifications, email alerts, and mobile push to approvers, capture justification notes, and maintain a detailed audit trail. Allow one-time overrides, temporary cap increases, and emergency bypass codes governed by role-based access control.
Integrate SLA Predictor and GeoHeat Overlay to assign an impact score to each address, prioritizing queue order and approvals for high-value or time-critical locations during surges. Provide configurable weighting (e.g., SLA risk, claim severity, geo intensity), tie-break rules, and transparent scoring explanations shown to users and in logs. Ensure safe fallbacks when predictors are unavailable and allow manual priority boosts with audit logging.
Deliver real-time visibility into cap utilization across organization, region, and branch with progress indicators toward hard/soft caps, forecasts of run-out times, and historical trends by day/week/event. Provide configurable alert thresholds with in-app, email, and SMS notifications for approaching or breached caps. Include drill-down to job lists, exportable reports, and filters by timeframe, branch, and event to support rapid decision-making.
Allow creation of cap templates tailored for surge scenarios (e.g., storm response) that define ramp-up/ramp-down limits over a configurable event window. Support manual activation, scheduled start/stop, and event tagging for reporting. Provide branch-level exceptions, blackout periods, and auto-revert to baseline caps after the event. Include reconciliation tools to compare planned vs. actual consumption and suggest template adjustments for future events.
Divide your main wallet into sub‑wallets for branches, teams, or roles with fixed allocations, rollover rules, and expiry windows. Give local leads visibility and autonomy while preventing one region from consuming the entire balance, improving control across franchises.
Enable organization admins to create, edit, and archive sub-wallets (Branch Buckets) under the main wallet with names, branch codes, and optional parent-child relationships. Support assigning default buckets to teams, roles, or users and allow one level of nesting. Display real-time balances and state (active/archived). Enforce uniqueness of names/codes per organization and prevent deletion when balances or pending reservations exist. Integrate with RoofLens organization and user directories for ownership and access mapping. Provide validation, error messaging, and safe rollbacks for all CRUD actions.
Provide recurring allocation schedules from the main wallet to Branch Buckets with fixed amounts, start/end dates, and cadence (weekly, biweekly, monthly). Support proration for mid-cycle joins, immediate one-time top-ups, per-period caps, and auto-top-up when balances drop below a configurable threshold. Allow selection of funding source (main wallet balance or payment method) and define behavior when funding fails (retry policy, alerting, partial allocation). Log all allocation events and expose them in UI and API.
Allow bucket-level configuration of unused credit rollover percentages or absolute limits per period, with configurable expiry windows and grace periods. Define what happens to expired credits (return to main wallet or forfeit) and support calendar-anchored or allocation-anchored windows. Handle time zone consistency at the organization level. Surface "expiring soon" counters and tooltips in the UI and expose policy metadata via API. Ensure atomic application of rollover and expiry at period close with idempotent processing and comprehensive error handling.
Implement bucket-level access controls and spend rules, including who can view, spend from, or manage a bucket. Support per-user and per-role daily/monthly spend limits, allowed job types (e.g., measurement, damage map, estimate), and soft versus hard limits with optional approval workflows for overages. Map users to default buckets by branch/team and block cross-bucket spending unless explicitly permitted. Enforce rules at transaction time with clear error states and audit all policy evaluations.
Automatically determine the charge bucket when a user initiates a RoofLens job using a deterministic order: project/batch override, user default, team default, then branch default. Reserve credits atomically at submission, release on failure, and convert reservations to charges on job start. Support configurable behavior when a bucket lacks funds (block, route to approval, or allow fallback if permitted). Ensure idempotent charging to prevent double-billing and handle partial refunds or job retries cleanly. Provide clear UI prompts for allowed overrides and transparent charge attribution on receipts and invoices.
Deliver dashboards and reports showing balances, allocated versus spent by period, burn rate, forecasted run-out dates, top spenders, and spend by job type per bucket. Provide filters by branch, team, role, and date range; CSV export; and scheduled email summaries. Visualize rollover and expiry impacts and call out anomalies (e.g., sudden spikes). Respect permissions so users only see authorized buckets. Optimize for performance with paginated queries and cached aggregates updated near real time.
Maintain an immutable audit log for all bucket-related events, including creation, updates, allocations, rollovers, expiries, top-ups, spend transactions, overrides, and approvals, with actor, timestamp, IP, and before/after values. Provide configurable alerts for low balances, allocation failures, upcoming expiries, and breached limits via email and Slack. Expose webhook events with signed payloads and retry/backoff policies for external integrations. Offer searchable UI for audits with filters and export capability.
Just‑in‑time auto top‑ups driven by forecasted demand from pipeline volume, scheduled flights, weather alerts, and historical burn. Set min/max refill amounts and preferred funding sources, get proactive alerts, and avoid work stoppages from surprise low balances.
Compute rolling forecasts of account balance consumption over a configurable look‑ahead window (e.g., 3–14 days) using inputs from active pipeline volume, scheduled drone flights, regional weather alerts, and historical burn rates. Expose a service that outputs projected daily usage, recommended next refill date and amount, and confidence intervals, with graceful degradation to heuristic models (e.g., moving averages) when inputs are missing. Recalculate forecasts on relevant events (new jobs, schedule changes, severe weather alerts, sudden consumption spikes) and at a minimum daily cadence. Provide per‑organization/workspace scopes, configurable business hours/timezone handling, and clear API/contract for the refill decision module. Ensure low-latency responses (<300 ms p95) and resiliency (retries, circuit breakers) to keep refill decisions timely.
Enable admins to define trigger thresholds and guardrails that govern automatic refills, including minimum balance to trigger, minimum/maximum refill amounts, rounding rules, daily/weekly caps, and blackout windows. Support per-organization defaults with workspace-level overrides and environment-based feature flags. Allow rule evaluation to incorporate forecast confidence (e.g., increase refill amount when high-confidence surge is predicted) and to halt automation when accounts are on hold. Provide REST/GraphQL APIs and admin UI for creation, validation, simulation (“what‑if” preview), and versioned change history. Respect timezones and business hours when calculating triggers and scheduling refills.
Allow multiple payment methods per account (primary and fallbacks) with prioritized routing and automated retries. Store cards and ACH mandates via a PCI‑compliant vault using tokenization, and support pre‑authorization checks and micro‑deposits for ACH where required. Implement idempotent payment execution, exponential backoff on failures, configurable retry windows, and automatic failover to backup methods. Expose webhooks and events for payment outcomes, update balance atomically upon confirmation, and reconcile against provider ledgers daily. Support regional compliance (e.g., SCA for EU cards) and surface clear error codes and recovery steps.
Deliver proactive notifications when forecasted balance will breach thresholds within a configurable window, when refills are scheduled, executed, or fail, and when manual intervention is required. Support in‑app, email, and SMS channels with user-level preferences and quiet hours. Provide approval workflows for refills above a configurable amount or during blackout windows, with role‑based access control, approver routing, SLAs, and escalation paths. Include a real‑time activity feed, digest summaries, and localized message templates. All approvals and actions must be auditable and tamper‑evident.
Integrate with internal job pipeline, flight scheduling systems, and third‑party weather services to supply the forecast engine with accurate, timely inputs. Provide connectors for common CRMs and job systems used by roofing contractors, flight planners, and at least one severe weather alert API, with clear mapping of fields to demand signals. Define polling and webhook ingestion strategies, schema validation, deduplication, and backfill processes. Implement retry/backoff, dead‑letter queues, and connector health dashboards with alerting on data freshness SLAs. Normalize data into a unified model that supports regional segmentation and seasonality.
Orchestrate just‑in‑time refill execution based on forecast outputs and configured rules, choosing the optimal time to top up to avoid low balances while minimizing cash tied up. Enforce safeguards such as rate limits (e.g., one successful refill per N hours), daily/weekly caps, and anti‑thrash logic to prevent frequent small refills. Support timezone-aware scheduling, blackout periods, and idempotent job handling with concurrency control. Provide clear state transitions (scheduled, pending payment, confirmed, failed, canceled) and automatic re‑scheduling on transient failures.
Record and expose the rationale behind each refill decision, including the forecast snapshot, input signals, rules evaluated, and payment outcomes. Maintain an immutable audit log of configuration changes, approvals, notifications, and financial transactions with user and timestamp metadata. Provide dashboards and exports (CSV/API) for refill history, forecast accuracy, avoided work stoppages, and spend distribution by funding source. Support filtering by date range, workspace, and project tags, enabling finance and ops to reconcile and optimize settings.
Require each address spend to carry tags (cost center, campaign, carrier, job ID) for clean attribution. Export detailed spend to accounting/ERP, track ROI by storm event or channel, and hold teams accountable with clear, drill‑downable reports.
Implement a mandatory tag schema for all spend records associated with an address/job, including cost center, campaign, carrier, and job ID. Provide server- and client-side validation, field typing, and normalization (e.g., casing, whitespace, allowed characters). Support inheritance of default tags from parent objects (account, project, storm event) with the ability to override at the line-item level. Prevent save/submit of estimates, invoices, and procurement costs unless required tags are present and valid. Expose validation errors via API and UI, and support configurable required/optional fields per tenant. Outcome: every spend line is consistently attributed for accurate reporting and downstream integrations.
Provide an admin console to define and manage allowed tag values and structures (e.g., predefined lists for cost centers, carriers, campaigns), including hierarchical tags, effective dates, deprecations, and merges (with automatic backfill/migration). Enable role-based permissions for who can create, edit, or apply tag values. Include bulk upload/export of dictionaries, validation rules (regex/length), and localization/aliases for display names. Ensure tenant scoping and auditability of governance actions. Outcome: controlled vocabularies that prevent tag sprawl and ensure clean, consistent attribution across the organization.
Design intuitive UI components to assign, view, and edit tags at the address/job level and on individual spend line items. Include quick-pick lists from dictionaries, search-as-you-type, recent/favorites, and clear required-field indicators with inline validation. Support inheritance preview (show which child records will be affected) and batch edit within a job. Provide status badges for "Missing Tags" in lists and mobile-friendly forms for field teams. Outcome: fast, low-friction tagging that increases completion rates without slowing workflows.
Enable bulk operations to apply or modify tags across selected addresses/jobs/spend lines, with conflict detection and preview. Provide CSV import with column-to-tag mapping, validation reports, and partial success handling. Support rule-based auto-tagging (e.g., derive carrier from claim number pattern, map campaign from source UTM, default cost center by branch) and scheduled backfills for historical data. Offer public APIs to submit tag updates at scale with idempotency keys and rate limits. Outcome: efficient onboarding and ongoing maintenance of consistent tags across large datasets.
Deliver export pipelines (CSV download, SFTP delivery, REST webhook) that include detailed spend line items with associated tags and identifiers (job ID, address, customer, GL mappings). Provide configurable field mappings per integration (e.g., QuickBooks, Sage, NetSuite), scheduling, incremental exports with idempotency, and retry/error reporting with alerts. Include a test/sandbox mode and sample files for validation. Outcome: seamless handoff of tagged spend to accounting/ERP for reconciliation and financial reporting by cost center, campaign, carrier, and job.
Provide analytics that aggregate revenue, cost, and margin by tags (storm event, campaign, cost center, carrier, job ID) with time filters and comparisons. Enable drill-down from summary tiles and charts to address-level details and underlying spend lines. Include saved views, scheduled email exports, and CSV download. Support cross-filtering, multi-select tags, and permissions-aware data visibility. Outcome: actionable insights to track ROI by event or channel and hold teams accountable with transparent, drill-downable reports.
Record a complete, immutable history of tag changes on addresses, jobs, and spend lines, capturing who changed what and when, with before/after values and reason codes. Provide UI to view history, filter by user/tag/date, and revert selected changes with safeguards. Expose audit data via API and include it in export logs for compliance. Outcome: traceability that supports reviews, dispute resolution, and accountability across teams.
When you bulk import or create Route Bundles, the wallet earmarks the exact credits needed and shows reserved vs. available in real time. Prevents mid‑run failures, auto‑releases unused reserves after SLA windows, and keeps crews moving without manual juggling.
Implement an atomic reservation service that calculates the exact credits required per route bundle based on bundle size, imagery type, processing options, and SLA, then earmarks those credits as “Reserved” (not consumed) in the organization wallet. Prevent oversubscription under concurrency with transactional locking and idempotency keys. Support an all-or-nothing reservation policy per bundle with an optional configurable partial-reserve fallback and automatic rollback on failure. Expose REST endpoints and internal events for reservation create/update/cancel, and integrate with Route Bundle create/edit flows, wallet top-up, and multi-tenant org wallets.
Provide real-time wallet visibility in UI and API showing Available, Reserved, and Consumed balances, plus a per-bundle allocation breakdown. Push live updates via WebSocket/SSE and render countdown timers to SLA expiry for each reservation. Include filters (project, date range, bundle, user), tooltips explaining states, and quick actions to release or extend holds. Ensure performant aggregation for large accounts, mobile-responsive views, and secure multi-tenant scoping.
Introduce a resilient scheduler that automatically releases unused reserved credits when SLA windows expire or when bundles are canceled. Make SLA duration configurable per organization and per route type; support grace periods, manual extensions, and business-hours-aware timers. Handle partial consumption by releasing the remainder, ensure idempotent releases, persist job state for recovery on restart, and emit notifications and ledger entries for every release action.
Add a pre-run validation gate that verifies the required credits are reserved and consistent with the planned tasks before a run can start. Block initiation if mismatches are detected and provide remediation flows to top up the wallet, shrink the bundle, or re-attempt reservation. Enforce checks at both API and UI layers, support retries with exponential backoff, and apply distributed locks during run initiation to maintain reservation integrity and prevent mid-run failures.
Enhance bulk import workflows to compute required credits on the fly and place reservations transactionally per bundle during CSV uploads and API submissions. Provide asynchronous processing with job IDs, progress tracking, and granular error reporting for insufficient credits, invalid rows, and conflicts. Support idempotency keys to avoid double-reserving, apply rate limiting, and emit webhooks/callbacks upon completion or failure with a per-record outcome summary.
Deliver configurable notifications and webhooks for reservation lifecycle events including low available credits, reservation success/failure, impending SLA expiry, auto-release executed, and manual overrides. Offer in-app, email, and optional SMS channels with per-organization thresholds and per-user preferences. Include contextual deep links to wallet top-up and bundle details, deduplicate noisy alerts, and honor quiet hours and role-based visibility.
Create an immutable audit ledger that records reserve, consume, extend, release, and refund events with timestamps, actor, origin (UI/API), bundle/job references, previous/new balances, and correlation IDs. Provide filtering, search, and CSV export in the admin UI along with a read-only API for integrations. Implement retention policies, tamper-evident signing, and reconciliation views to support dispute resolution and financial audits.
Issue time‑boxed, geofenced micro‑wallets to subcontractors or Guest Pass users with strict per‑job limits. Credits can only be spent on the assigned address(es), with full audit in the Custody Ledger—enabling secure collaboration without risking your main balance.
Enable account owners to create and fund micro-wallets (Guest Pockets) tied to one or more job addresses, with configurable budget, allowed SKUs (e.g., AI Measurement Report, Damage Map, Automated Estimate), geofence geometry (radius or polygon), and validity window. Pockets can be assigned to existing subcontractor users or issued via Guest Pass to external collaborators. Funds are drawn from the main account balance and displayed as a dedicated pocket balance. Provide templates and cloning to speed setup for common job types. Persist pocket state and relationships to jobs, users, and the Custody Ledger. Surface creation/edit UI in the Job and Billing modules and expose the capability via API for automation.
Enforce that all pocket-funded transactions occur within the assigned job geofence and address set. Validate spend requests by cross-checking order metadata (address normalization), asset GPS/EXIF, drone flight logs, and uploader device location (when available). Block or require approval for attempts outside the geofence or for mismatched addresses, and present clear error messaging. Store geospatial evidence and evaluation outcomes in the Custody Ledger for auditability. Integrate enforcement into the checkout/purchase flow for reports and processing orders across web and API channels.
Support start and end times for each pocket with automatic suspension at expiry and auto-reclaim of any unused funds back to the parent account. Allow owners to pause/resume pockets, extend end dates, and set pre-expiration reminders (e.g., 24/72 hours). Ensure all state transitions are atomic and recorded in the Custody Ledger with before/after balances. Handle timezone normalization, partial refunds for in-flight orders, and idempotent retries to prevent double-reclaims.
Provide granular controls per pocket: total cap, daily cap, per-transaction cap, and whitelisted SKUs/quantities (e.g., max 2 AI Measurement Reports, 1 Damage Map). Enforce limits consistently across UI and API, with deterministic rule evaluation and precise error messaging. Prevent non-whitelisted fees or add-ons from being charged to the pocket. Support rule previews during setup and real-time balance/limit checks during checkout. Log all rule evaluations and outcomes to the Custody Ledger.
Write immutable ledger entries for every pocket event: creation, funding, configuration changes, geofence validations, successful/failed spends, refunds, approvals, expiry, and reclaims. Each entry captures actor identity (user or guest), timestamp, IP/device fingerprint, geospatial validation artifacts, before/after balances, and references to jobs, orders, and assets. Provide searchable UI and export (CSV/JSON) with role-based access controls to support reconciliation and dispute resolution.
Allow issuing Guest Pass links (email/SMS magic links) that grant least-privilege access scoped to the assigned pocket and job(s). Support optional MFA, device binding, and revocation. Require acceptance of terms and capture consent records. Trigger lightweight KYC prompts when cumulative pocket spend exceeds configurable thresholds. Provide a minimal guest workspace showing only allowed services, balance, geofence map, and expiration details to reduce friction while maintaining security.
Offer configurable notifications for key pocket events: funding, low balance thresholds, attempted rule/geofence violations, successful spends, and upcoming/actual expiry. Enable optional approval workflows for spends over a threshold, outside business hours, or flagged by risk signals. Support email, in-app, and webhook channels with delivery tracking and retries. Approvals must be time-bound, auditable, and fail-safe (auto-decline or auto-approve per policy).
Innovative concepts that could enhance this product's value proposition.
Auto-prioritizes storm uploads by hail size, due date, and drive-time; bulk assigns rush jobs in one click. Cuts manual triage and speeds same‑day bids by 30%.
Phone-guided AR corridors and live coverage heatmaps prevent gaps while flying. Instant QC flags missed facets and low overlap, slashing re‑flights.
Tamper-evident PDFs with cryptographic hashes, GPS/time stamps, and full revision trails. Desk adjusters verify integrity in seconds, reducing scope disputes.
Maps detected materials and damage to jurisdiction‑specific line items with prices, ready for Xactimate export. Delivers consistent, defensible estimates in one pass.
Locked estimate templates, variance thresholds, and approver checkpoints enforce consistency across branches. Real‑time margin alerts stop over‑discounting.
Passwordless sign‑in with WebAuthn and scannable crew badges authorizes on‑site uploads. Every image is traceable to a person and device.
Prepaid, pay‑per‑address wallet with team quotas and auto top‑up. Solo users control spend; franchises cap storm‑surge burn.
Imagined press coverage for this groundbreaking product concept.
Imagined Press Article
For immediate release RoofLens today announced the general availability of its SaaS platform that converts drone and aerial photos into precise roof measurements, damage maps, and automated line‑item estimates. Built for small-to-mid-size roofing contractors and insurance adjusters, RoofLens eliminates manual measuring and spreadsheet juggling to produce ready‑to‑send PDF bids in under an hour—cutting estimating time by up to 70% and reducing disputes with defensible, verifiable evidence. The platform ingests imagery captured by on‑site technicians or third‑party aerial providers and reconstructs the roof in high fidelity, outputting accurate areas, perimeters, slopes, penetrations, and edge counts. RoofLens then maps detected materials and damage to jurisdiction‑ and carrier‑specific line items and prices, generating a clean, standardized estimate that can be exported to Xactimate, CoreLogic/Symbility, or shared as a tamper‑evident PDF. “Speed and trust decide who wins the job,” said Alex Morgan, CEO of RoofLens. “With RoofLens, a solo estimator can capture a roof, generate defensible quantities, and produce a polished, carrier‑aligned estimate in one sitting. It removes the busywork that slows teams down and replaces it with confidence—confidence that your numbers are right and your documentation will hold up.” Designed around the day‑to‑day realities of the field, RoofLens offers fast, no‑frills workflows for owner‑operators and robust controls for franchises and carriers. Solo Bid Builder users get per‑job pricing, same‑day turnaround, and ready‑to‑send PDFs. High‑volume teams can bulk import addresses, auto‑prioritize rush jobs, and keep work moving with live capacity and SLA insights. Insurance Desk Adjusters get defensible measurements, damage annotations, and an audit trail that simplifies reviews and minimizes back‑and‑forth. Key capabilities include: - Measurement and mapping: High‑accuracy area, edge, pitch, and penetration counts from drone and aerial imagery, with loss‑critical features labeled and measured. - Automated estimating: CodeCrosswalk maps materials and damages to the right jurisdiction- and carrier‑specific line codes; PricePulse syncs regional price lists and adjusts for storm surges; SmartAssemblies expand one‑click assemblies into fully quantified line items with prewritten notes. - Consistency and control: Template Lockstep enforces centrally managed estimate templates across branches; Approval Matrix routes bids for the right sign‑offs; Variance Bands and Margin Locks keep estimates within safe, profitable guardrails. - Evidence and defensibility: DisputeLock PDF with SignSeal, GeoSeal, QR Verify, ProofLinks, and a Custody Ledger provides a verifiable chain‑of‑custody, tamper evidence, and click‑through context for every line item. - Seamless export: ExportPreflight checks code completeness, required photo attachments, and carrier formatting before outputting ESX/CSV or sending via API. “RoofLens gives our desk team the two things we value most: consistency and verifiability,” said Priya Shah, a licensed public adjuster and early evaluator of the platform. “The line items match the carrier’s expectations, photos are tied to time and GPS, and every change has a clear reason. That combination reduces friction and helps policyholders get fair outcomes faster.” The platform is equally at home in the driveway and the back office. Sales reps can present vivid visuals and fast, defensible numbers to earn homeowner trust on the spot. Office leads can triage storm events using live capacity, route bundles, and SLA predictors. Production planners can turn approved scopes into clean material orders and schedules with CSV/ERP exports, minimizing overages and delays. RoofLens is engineered for transparency. Every report can carry a scannable QR that opens a lightweight verification page for reviewers—no software installs required. Adjusters can confirm document integrity, review chain‑of‑custody entries, and click through ProofLinks to see exactly which photos and measurements support each line item. When templates update, CodeCrosswalk highlights deltas so users know precisely what changed and why. “Contractors need to move at storm speed without sacrificing accuracy or profits,” said Jordan Lee, Head of Product at RoofLens. “We built RoofLens so that a first‑time user can generate a defensible estimate in under an hour, while multi‑branch organizations get the controls they need to scale consistently: locked templates, guardrails, approvals, and a crystal‑clear audit trail.” Availability and pricing RoofLens is available today in the United States and Canada. The platform supports a flexible, prepaid per‑address wallet with optional branch allocations, approvals, and auto top‑ups. Solo users can start on a pay‑per‑job basis, while high‑volume teams can unlock bulk pricing and advanced controls. New customers can be live in a day with guided onboarding and template setup. About RoofLens RoofLens is a software platform that turns drone and aerial photos into precise roof measurements, damage maps, and automated line‑item estimates. Purpose‑built for contractors, adjusters, and franchises, RoofLens eliminates manual measuring and spreadsheet guesswork, producing carrier‑aligned, ready‑to‑send PDFs in under an hour. With verifiable evidence and built‑in guardrails, teams work faster, reduce disputes, and protect margins. Media contact Press: press@rooflens.com Phone: +1‑555‑013‑4210 Web: https://www.rooflens.com
Imagined Press Article
For immediate release RoofLens today introduced a Storm Triage and Routing Suite designed to help roofing contractors and adjusters handle surge demand during hail and wind events. The suite combines live capacity management, automated prioritization, and turn‑by‑turn route optimization so teams can complete more high‑impact addresses the same day—without manual juggling. Built directly into the RoofLens platform, the suite centers on Capacity Balancer, SLA Predictor, Route Bundles, GeoHeat Overlay, Smart Rebalance, and a Triage Audit Trail. Together, these capabilities orchestrate people, vehicles, and deadlines in real time, making it easy to move rush jobs to the front of the line while keeping staff utilization healthy and transparent. “When a storm hits, the bottleneck moves from estimating to orchestration,” said Jordan Lee, Head of Product at RoofLens. “Our Storm Triage and Routing Suite automates the hard parts—who should do what, in what order, and by when—so coordinators can focus on customers. The result is higher same‑day completion rates, fewer missed SLAs, and significantly less windshield time.” How it works - Capacity Balancer distributes triaged jobs across estimators and drone operators using live capacity, time windows, and skill tags like steep, tile, or commercial. It prevents overload and raises same‑day completion without spreadsheets. - SLA Predictor calculates a per‑address probability of meeting the due time based on queue length, route ETA, daylight, and weather. It flags at‑risk jobs early and recommends actions—reassign, bundle, or rush—to protect commitments. - Route Bundles auto‑group nearby addresses into optimized runs with an ideal stop order. Leads can assign or reassign an entire bundle in one click to cut drive time and lift throughput. - GeoHeat Overlay layers hail sizes, wind swaths, and claim density on the triage board. Coordinators instantly spot high‑impact clusters and move them to the top, ensuring the worst‑hit customers are served first. - Smart Rebalance reshuffles priorities when new rush jobs arrive, honoring locks and preferences, and notifies affected users with clear reasoning to minimize confusion. - Triage Audit Trail logs the rationale behind every priority and assignment—hail metrics, due date, drive‑time, and rule hits. The record can be exported to defend decisions with carriers and management. The Storm‑Event Coordinator is a core RoofLens user persona: office leads triaging hundreds of addresses after a storm, balancing due dates, crews, and budgets. The new suite gives them an end‑to‑end command center that connects planning with execution and documentation. Coordinators can bulk import addresses, tag cost centers, reserve wallet credits for each run, and track live presence with scan‑in/scan‑out events from the field. “During last season’s hail surge we were drowning in sticky notes and map tabs,” said Fran Alvarez, regional operations director at a multi‑branch roofing franchise and an early pilot customer. “With RoofLens, our coordinators could prioritize the most impacted neighborhoods, auto‑build route bundles, and see which visits were at risk hours in advance. We took on more work without burning out the team—and our SLAs actually improved.” The suite pairs tightly with RoofLens’s evidence‑grade capture and estimating tools. Field Drone Operators get mobile flight presets and QC feedback to ensure usable results on the first visit. Estimators receive jobs with pre‑applied rules for the carrier and jurisdiction, and can produce standardized, defensible estimates quickly. When supplements are needed, Revision Diff and ProofLinks shorten negotiations by showing exactly what changed and why. Triage doesn’t stop at logistics. RoofLens also helps organizations manage surge budgets responsibly. Features like SurgeCap, Branch Buckets, Predictive Refill, Cost Tags, Job Reserve, and Guest Pockets provide granular control over spend by day, week, event, branch, or subcontractor. Credits are earmarked for route bundles, unused reserves auto‑release after SLA windows, and every dollar maps cleanly to the right storm event and cost center. “Storm response is a reliability problem,” added Alex Morgan, CEO of RoofLens. “Customers remember who showed up first and who delivered a clear, consistent bid. Our triage and routing suite is about making those promises and keeping them—at scale and under pressure.” Availability The Storm Triage and Routing Suite is available today for all RoofLens customers in the United States and Canada. The capabilities are included in platform plans, with advanced budget controls available as add‑ons. New customers can be live in a day with guided setup. About RoofLens RoofLens is a software platform that turns drone and aerial photos into precise roof measurements, damage maps, and automated line‑item estimates. Purpose‑built for contractors, adjusters, and franchises, RoofLens eliminates manual measuring and spreadsheet guesswork, producing carrier‑aligned, ready‑to‑send PDFs in under an hour. With orchestration, evidence, and guardrails built in, teams work faster, reduce disputes, and protect margins. Media contact Press: press@rooflens.com Phone: +1‑555‑013‑4210 Web: https://www.rooflens.com
Imagined Press Article
For immediate release RoofLens today announced the availability of an evidence and compliance toolkit that brings tamper‑evident documents, verified imagery, and a full chain‑of‑custody to every job. The toolkit—centered on DisputeLock PDF, SignSeal, GeoSeal, QR Verify, ProofLinks, RedactSafe, Revision Diff, and a Custody Ledger—gives contractors, independent adjusters, and carriers a shared foundation of truth that reduces scope disputes and speeds approvals. Insurance reviews often stall when reviewers question whether photos are job‑specific, whether measurements are accurate, or why a line item changed. RoofLens solves these pain points at the document and data level. Each report can be cryptographically sealed, watermarked with GPS/time/altitude, and accompanied by a click‑through audit trail that shows exactly how each measurement and line item was derived. “Reviewers want to trust what they’re seeing,” said Alex Morgan, CEO of RoofLens. “With RoofLens, that trust is earned by design. Every page section can carry a verifiable watermark, every file can be digitally signed, and every change is recorded with an author, timestamp, and reason. The result is fewer emails back and forth and faster, fairer outcomes for policyholders.” Key components - DisputeLock PDF: Produces a tamper‑evident, court‑ready document that desk reviewers can verify in seconds. The moment a field is altered, the seal breaks and flags clearly. - SignSeal: Applies standards‑based digital signatures (PAdES/LTV) from RoofLens and optional co‑signers so validation works long‑term without extra tools. - GeoSeal: Watermarks each photo, measurement, and page section with verified GPS, time, altitude, and capture confidence. A roll‑up badge summarizes coverage integrity to disarm claims of stock photos or post‑hoc edits. - QR Verify: Adds a scannable QR and short link to every DisputeLock PDF that opens a lightweight verification page—hash match, capture timestamps, and signer list—no install required. - Custody Ledger: Embeds an append‑only chain‑of‑custody record showing who captured, uploaded, edited, approved, and shared, complete with device IDs, GPS/time, and WebAuthn identity. - ProofLinks: Attaches verifiable evidence and reasoning to every line item—cropped photos, detected damage labels, measurement references, and relevant code/policy citations. - RedactSafe: Enables role‑based, permanent redactions for PII and policy numbers that maintain a verifiable manifest, preserving tamper evidence while sharing privacy‑compliant copies. - Revision Diff: Generates a clear, color‑coded summary of what changed between versions—line items added or removed, quantity shifts, notes, and attachments—so supplements read like a concise commit history. For Insurance Desk Adjusters and carrier reviewers, the toolkit means less detective work. Reviewers can scan the QR on a PDF, confirm the document’s integrity, and drill into the context behind any line item in moments. For Policy Advocate Priya and other public adjusters, it provides a consistent way to present claims with defensible evidence and a transparent rationale. For contractors, it reduces re‑measures, re‑flights, and callbacks by setting a higher standard of documentation from the start. “RoofLens lets us lead with evidence, not opinion,” said Quinn Parker, QA lead at a regional contractor who participated in early access. “When a reviewer asks why a step flashing line is included, we point them to the ProofLink: a photo, the measurement reference, and the code citation. The conversation shifts from ‘if’ to ‘how fast can we approve this?’” The toolkit integrates seamlessly with RoofLens capture and estimating workflows. Field operators benefit from on‑site QC to eliminate gaps and ensure consistent image resolution. Estimators get CodeCrosswalk and PricePulse to align line items and unit prices with carrier expectations. Before export, ExportPreflight checks that required photos and notes are present and that grouping, order, and formatting meet carrier requirements. Security and privacy are first‑class concerns. RoofLens supports passkey‑based authentication and scannable crew badges to ensure each image is traceable to an authorized person and device. Device Lock verifies hardware integrity and blocks rooted or emulated devices, while Offline Pass allows secure capture at sites with limited signal. Every action is recorded in the Custody Ledger for accountability and compliance. “Too often, good work is undermined by missing context or weak documentation,” added Jordan Lee, Head of Product at RoofLens. “We designed our evidence toolkit to meet reviewers where they are—PDFs and links—and give them instant, verifiable context without extra software. It saves everyone time and reduces conflict.” Availability The evidence and compliance toolkit is available today for all RoofLens customers. DisputeLock PDF, SignSeal, GeoSeal, QR Verify, ProofLinks, RedactSafe, Revision Diff, and the Custody Ledger can be enabled per template, with defaults controlled centrally for franchises and carriers. About RoofLens RoofLens is a software platform that turns drone and aerial photos into precise roof measurements, damage maps, and automated line‑item estimates. With verifiable evidence and built‑in guardrails, teams work faster, reduce disputes, and protect margins across residential and commercial projects. Media contact Press: press@rooflens.com Phone: +1‑555‑013‑4210 Web: https://www.rooflens.com
Imagined Press Article
For immediate release RoofLens today announced a comprehensive AR flight capture and quality control toolkit that helps field teams capture reconstruction‑ready photo sets on the first visit—even in challenging conditions. The toolkit combines Corridor Auto‑Plan, WindSmart Pathing, Overlap Guardian, Facet Finder, Altitude Gate, and QC Instant Replay to deliver consistent coverage, reduce blurry shots, and eliminate costly re‑flights. On‑site capture quality is the foundation of fast, defensible estimates. Missed facets, low overlap, and inconsistent image resolution cause back‑office delays and repeat visits that drain time and budgets. RoofLens removes guesswork with live, in‑app guidance that turns best practices into a repeatable, guided routine for any technician. “Field crews shouldn’t need to be mapping experts to capture great data,” said Jordan Lee, Head of Product at RoofLens. “RoofLens turns the roof outline into an AR playbook—where to fly, how high, what angle—then monitors overlap and coverage live. If something slips, the app nudges the pilot to adjust in the moment, not after they’ve driven away.” Toolkit highlights - Corridor Auto‑Plan: One‑tap AR corridors auto‑generated from the roof outline and camera FOV set ideal passes, gimbal angles, and overlap targets. Crews get airborne in under a minute with a plan that guarantees full‑facet coverage, even on steep or complex roofs. - WindSmart Pathing: Live wind and gust sensing adapts headings, speed, and pass spacing on the fly. Visual and haptic prompts help counter drift and yaw so overlap stays on target in breezy conditions, reducing blurry shots, re‑flys, and battery swaps. - Overlap Guardian: A real‑time forward/side overlap gauge overlays the corridor. If coverage dips below threshold, lanes turn red and the app recommends slowing, tightening, or adding a pass. - Facet Finder: Computer vision identifies roof facets, dormers, valleys, and penetrations from the live feed, pinning any uncaptured surfaces with AR markers. Prompted obliques ensure loss‑critical features are documented for accurate measurements and damage mapping. - Altitude Gate: AR altitude bands lock in the ideal height for target ground sample distance and local airspace rules. Audible cues alert if the aircraft strays high or low, keeping scale accuracy tight and preventing reshoots due to inconsistent image resolution. - QC Instant Replay: On landing, RoofLens auto‑builds a coverage heatmap and gap list. Tap any gap to launch a micro‑mission that fills it in one or two passes, then generate a QC certificate to attach to the job record. The toolkit is designed for Field Drone Operators who value mobile UX, reliable coverage, and rapid feedback. It also benefits office teams by ensuring that every capture meets the quality bar for reconstruction, measurement, and damage detection—accelerating downstream estimating and reducing disputes. “Before RoofLens, we’d discover missing obliques back at the office,” said Casey Nguyen, commercial capture lead at an industrial roofing firm in the Midwest. “Now the app catches gaps on site and spins up micro‑missions to fix them. We’ve cut re‑flights dramatically and our estimators get usable data the first time.” Safety and compliance are integrated into the workflow. Preflight Attest provides role‑based safety checklists aligned to Part 107 and site requirements, signed with the user’s passkey. Site Auto‑Claim locks uploads to the right job using geofence verification after a badge scan, eliminating misfiled photos and speeding on‑site kickoff. Device Lock ensures only verified hardware and accounts can upload, blocking rooted or emulated devices. Offline Pass supports secure capture in low‑signal environments, storing time‑boxed, geofenced credentials in secure hardware until sync. Once synced, RoofLens’s estimation engine turns consistent photo sets into precise measurements and automated line items aligned to jurisdiction and carrier rules. ExportPreflight confirms that required photos, notes, grouping, and formatting are present before Xactimate export. The result is a clean, defensible submission with minimal edits. “Great capture is the surest way to protect SLAs and margins,” added Alex Morgan, CEO of RoofLens. “Our AR toolkit helps new pilots fly like seasoned pros, and it gives managers proof the job was done right—on the first visit.” Availability The AR flight capture and QC toolkit is available today on the RoofLens mobile app for supported iOS and Android devices and common prosumer drones. Customers can enable the features per template and user role, with training resources and quick‑start presets included. About RoofLens RoofLens is a software platform that turns drone and aerial photos into precise roof measurements, damage maps, and automated line‑item estimates. With guided capture, verifiable evidence, and built‑in guardrails, teams work faster, reduce disputes, and protect margins across residential and commercial projects. Media contact Press: press@rooflens.com Phone: +1‑555‑013‑4210 Web: https://www.rooflens.com
Imagined Press Article
For immediate release RoofLens today launched a suite of guardrails and pricing intelligence designed for multi‑branch franchises and growing contractors that need to standardize estimating, protect margins, and accelerate approvals across markets. The suite spans Template Lockstep, Approval Matrix, Variance Bands, Margin Locks, Region Profiles, Compliance Pulse, CodeCrosswalk, PricePulse, GapGuard, SmartAssemblies, and ExportPreflight—delivering consistency by default and flexibility when it counts. The challenge for distributed organizations is multiplying: more regions, more carrier preferences, and more ways to drift from the standard. RoofLens addresses this by centralizing the rules and templates that shape every estimate, then surfacing real‑time guidance and controls that keep local teams fast and compliant. “Consistency is the first ingredient of scalable profitability,” said Fran Delgado, Director of Operations Strategy at RoofLens. “We built this suite so franchise leaders can set the playbook once and know it’s being followed—without slowing down the field. When exceptions arise, they’re routed to the right approver with context and a clock, not lost in email.” What’s included - Template Lockstep: Centrally controlled estimate templates with versioning, one‑click rollouts, and safe rollback. Push updates across branches on a schedule, auto‑migrate in‑flight bids with a clear change diff, and lock critical sections to stop local edits. - Approval Matrix: Configurable approver workflows driven by role, dollar thresholds, margin floors, and exception types. Auto‑route bids for sign‑off, set SLAs, and approve or decline from web or mobile with reason codes. - Variance Bands and Margin Locks: Define allowed ranges for waste factors, labor hours, quantities, and discounts by roof type and market. Live margin tracking and guardrails prevent risky submissions, while color‑coded guidance and suggestions keep estimators moving. - Region Profiles: Package market‑specific rules into reusable profiles—permitted materials, code‑required adds, crew rates, taxes, and carrier preferences by ZIP or county. Auto‑apply on job creation so branches inherit the right rules by default. - Compliance Pulse: Real‑time dashboard and alerts tracking template drift, override frequency, approval latency, and branch margin variance. Drill into outliers, export audit packs, and send weekly scorecards to managers. - CodeCrosswalk and PricePulse: Automatically map detected materials and damages to the exact jurisdiction‑ and carrier‑specific line codes. Sync regional price lists with supplier feeds and storm‑surge adjustments, flag stale or mismatched lists, and lock to a carrier‑approved schedule per file. - GapGuard and SmartAssemblies: Prevent misses and conflicts by scanning the scope against roof geometry, climate zone, and carrier or franchise rules, then expand one‑click assemblies into fully quantified line items with prewritten notes. - ExportPreflight: Run readiness checks before Xactimate export—code completeness, required photo attachments, note compliance, grouping, ordering, and carrier‑specific formatting—to minimize edits and rejections. For Franchise Standardizer Fran and QA Compliance Quinn—two of RoofLens’s core personas—the result is a step change in control and visibility. Templates and pricing stay in lockstep with policy and market changes, while exceptions are handled quickly and audibly. Estimators receive guidance in the flow of work, not as after‑the‑fact corrections, so they stay productive and confident. “Before RoofLens, every branch had its own flavor of a ‘standard’ estimate,” said Marcus Hill, VP of Operations at a national roofing franchise that piloted the suite. “Now our templates roll out overnight, our approvals have teeth, and our margins aren’t left to chance. Reviewers spend less time nitpicking structure and more time approving deals.” The suite also helps production and finance teams. Production Planners can trust that area and edge counts, waste factors, and assembly choices produce accurate material orders and schedules, reducing overages and delays. Finance gains line‑of‑sight into pricing sources, discounting behavior, and margin trends by market, with exports ready for ERP ingestion and audit. All controls are layered on top of RoofLens’s evidence and capture foundation. Every estimate is backed by verifiable measurements and photos, complete with QR‑based verification and a custody trail. When rules or templates update, CodeCrosswalk maintains a versioned history and highlights deltas so teams understand what changed and why—vital for internal training and external reviews. “Guardrails should feel like a safety net, not a speed bump,” added Delgado. “Our approach nudges estimators toward the best path and gives leaders the levers to keep the business healthy—without sacrificing the responsiveness customers expect.” Availability The guardrails and pricing intelligence suite is available today for RoofLens customers with multi‑user plans. Template Lockstep, Approval Matrix, Variance Bands, Margin Locks, Region Profiles, and Compliance Pulse are included in enterprise tiers; CodeCrosswalk, PricePulse, GapGuard, SmartAssemblies, and ExportPreflight are available across tiers with advanced options for franchises and carriers. About RoofLens RoofLens is a software platform that turns drone and aerial photos into precise roof measurements, damage maps, and automated line‑item estimates. With guided capture, verifiable evidence, orchestration, and guardrails, teams work faster, reduce disputes, and protect margins across residential and commercial projects. Media contact Press: press@rooflens.com Phone: +1‑555‑013‑4210 Web: https://www.rooflens.com
Subscribe to receive a fresh, AI-generated product idea in your inbox every day. It's completely free, and you might just discover your next big thing!
Full.CX effortlessly brings product visions to life.
This product was entirely generated using our AI and advanced algorithms. When you upgrade, you'll gain access to detailed product requirements, user personas, and feature specifications just like what you see below.