Violerts - Enterprise NYC PropTech Compliance & Violation Monitoring SaaS

Executive Overview & The Problem#

New York City real estate professionals often need to investigate multiple government systems before making decisions about a property. Violations, permits, hearings, liens, certificates of occupancy, property records, and other compliance information can exist across disconnected municipal databases.

Violerts was created to turn that fragmented process into a centralized property intelligence platform.

When I joined the project, the application was closer to an early-stage MVP than an enterprise SaaS product. The platform had several technical and product limitations:

• Property identification was primarily based on individual addresses or BINs.
• AKA addresses, related BINs, and tax-lot relationships were not comprehensively resolved.
• Several high-value NYC datasets were missing or incomplete.
• Large scraping operations could result in HTTP 502 errors and memory exhaustion.
• Long-running background processes had limited visibility and observability.
• The React application generated redundant API requests and unnecessary Redux state updates.
• Property information was primarily presented through static tables instead of spatial GIS interfaces.
• Portfolio management was largely single-user.
• There was no granular organization/seat permission model.
• Notifications relied heavily on email rather than immediate SMS/web alerts.
• Subscription and feature access needed a more flexible SaaS billing architecture.

My responsibility was not simply to add individual features. I worked across the stack to evolve the product into a more reliable, scalable and commercially viable SaaS platform.

Architectural Approach & System Design#

The resulting architecture separated the application into several major responsibilities:

                    NYC MUNICIPAL DATA SOURCES
                              │
          ┌───────────────────┼───────────────────┐
          │                   │                   │
       DOB/BIS             FDNY/OATH           ACRIS
          │                   │                   │
          └───────────────────┼───────────────────┘
                              │
                     Scraper / Ingestion
                              │
                    DTO Transformation
                              │
                    Redis / Horizon Queues
                              │
                    ┌─────────┴─────────┐
                    │                   │
                 MySQL              Redis Cache
                    │                   │
                    └─────────┬─────────┘
                              │
                         Laravel API
                              │
          ┌───────────────────┼────────────────────┐
          │                   │                    │
       React UI           WebSockets          Notification
          │                   │                    │
      Leaflet GIS          Pusher             SMS / Email
          │
      Property Intelligence

Backend Architecture#

The backend was built with Laravel 11 and PHP 8.3, with Laravel responsible for:

• RESTful APIs
• Authentication and authorization
• Property and violation data
• Municipal data processing
• Background jobs
• Notification workflows
• Organization and seat management
• Stripe billing
• Webhook processing
• Export generation

I introduced strongly typed DTOs for scraped and transformed data using Spatie Data-style structures. This provided a consistent boundary between external municipal data and the application's domain models.

Instead of allowing scraper-specific payload structures to propagate throughout the application, incoming data was normalized before being persisted.

Asynchronous Processing#

Municipal data ingestion can involve large responses, slow external systems and unpredictable processing times.

Rather than handling these operations synchronously inside HTTP requests, I moved heavy workloads into Redis-backed Laravel Horizon queues.

The queue architecture separated workloads such as:

• Municipal scraping
• Data normalization
• Database persistence
• Email notifications
• SMS notifications
• Large exports
• Other long-running background operations

This prevented expensive workloads from blocking normal application requests.

Property & Address Resolution#

One of the most important domain challenges was that a single NYC property may have:

• Multiple street addresses
• Multiple BINs
• Multiple BBL/tax-lot relationships
• AKA/alias addresses
• Records filed under different identifiers

I integrated NYC GOAT/address intelligence to resolve related property identifiers and improve the relationship between a property and its municipal records.

This meant the system could build a broader property identity instead of treating an address as an isolated lookup key.

GIS & Spatial Intelligence#

A major part of the platform modernization was moving beyond traditional tables and introducing spatial context.

I built interactive mapping functionality using Leaflet GIS, allowing users to visualize property information geographically.

The mapping layer supported use cases including:

• Property locations
• Property boundaries
• Violation clusters
• Zoning-related spatial information
• Sidewalk geometry
• Historical map information

Sanborn Map Integration#

I also implemented a historical Sanborn map workflow so users could access relevant NYC fire insurance atlas information directly from the property experience.

Instead of forcing users to leave the application and manually search historical records, the system connected the relevant borough, volume and page information with the property interface.

This was particularly useful for users involved in architectural research, property due diligence and expediting.

Real-Time Notifications & Communication#

Violations and stop-work orders can have significant consequences when discovered late.

I designed a notification lifecycle that could react to newly available compliance information and notify relevant stakeholders.

The system supported:

• Email notifications
• SMS alerts
• Real-time application events
• Delivery tracking
• Retry handling
• Webhook reconciliation

For SMS, I implemented an outbound dispatch subsystem with delivery-state tracking and administrative visibility into the messaging lifecycle.

This gave the product a foundation for time-sensitive compliance notifications rather than relying exclusively on periodic manual searches or email digests.

Multi-Tenant Organization Architecture#

The original product experience was primarily designed around individual users.

I expanded the account model to support organizations and team-based workflows.

The architecture introduced concepts such as:

Organization
   │
   ├── Owner
   ├── Billing Admin
   └── Team Seats
          │
          ├── Portfolio Access
          ├── Property Access
          └── Collaboration

This allowed the application to enforce permissions around:

• Organizations
• Seats
• Portfolios
• Properties
• Billing capabilities
• Enterprise features

This was important for moving the application from an individual-user product toward a B2B SaaS platform.

Real-Time Property Collaboration#

I built an in-app property messaging experience using Pusher WebSockets.

Users could collaborate around specific property records rather than communicating outside the platform.

The workflow supported:

• Property-specific conversations
• Team member communication
• Compliance notes
• Document sharing
• Real-time message delivery

This connected compliance intelligence with the collaboration workflow required to act on that intelligence.

Stripe Billing & SaaS Monetization#

I implemented subscription infrastructure using Stripe and Laravel Cashier.

The billing architecture supported:

• Tiered subscription plans
• Stripe Checkout
• Plan upgrades
• Seat-based add-ons
• Free-trial onboarding
• SMS credit purchases
• Subscription-aware feature access

I also implemented application-level paywall and access-control logic so subscription state could control:

• Property limits
• Seat allocations
• Premium features
• SMS capabilities
• Organization functionality

This transformed billing from a static pricing concept into an application-aware SaaS monetization layer.

Frontend Performance & React Architecture#

The frontend was built using React and Redux, with Leaflet powering the GIS experience.

One of the performance problems I encountered was unnecessary API traffic caused by repeated state changes and duplicated data requests.

I reworked Redux state handling and introduced memoized selectors using reselect.

The goal was to make the UI request data based on actual state requirements rather than repeatedly triggering the same endpoints.

The result was a significantly more efficient frontend experience, with project measurements showing page-load improvements of more than 60% in affected workflows.

Key Technical Challenges & Solutions#

1. Fragmented NYC Property Identifiers#

Challenge#

A property could appear under multiple addresses, BINs or tax lots. Looking up only one identifier could result in incomplete compliance information.

Solution#

I implemented an address-resolution workflow around NYC GOAT data and related property identifiers.

The process became:

User Address
     ↓
Address Resolution
     ↓
Primary BIN / BBL
     ↓
AKA / Related BINs
     ↓
Municipal Dataset Lookups
     ↓
Normalized Property Records

This significantly improved the platform's ability to associate municipal records with the broader property identity.

2. Fragile Large-Scale Scraping#

Challenge#

Municipal systems can be slow and unpredictable. Large responses could cause memory exhaustion or gateway errors when processed synchronously.

Solution#

I redesigned the ingestion workflow around background processing.

Instead of:

HTTP Request
    ↓
Scrape
    ↓
Parse Everything
    ↓
Save Everything
    ↓
HTTP Response

the architecture became:

Request / Scheduler
       ↓
Create Job
       ↓
Redis Queue
       ↓
Laravel Horizon Worker
       ↓
Scrape
       ↓
Normalize
       ↓
Persist
       ↓
Notify

I also used chunked and stream-based processing for large exports to avoid loading entire datasets into memory.

This made heavy workloads more resilient and prevented them from competing directly with user-facing HTTP requests.

3. Turning a Single-User Product Into a B2B SaaS#

Challenge#

The platform needed to support organizations with multiple users while maintaining appropriate access boundaries.

A simple user-to-property relationship was no longer sufficient.

Solution#

I introduced organization-aware access control with ownership, billing administration and team-seat concepts.

Subscription state was also connected to authorization, allowing the application to enforce commercial limits directly at the API and application layers.

This created the foundation for larger property management companies, landlords, developers and professional expediting teams to use the platform collaboratively.

Results & Business Impact#

The engineering work transformed Violerts from a basic property lookup application into a broader compliance intelligence platform.

Broader Data Intelligence#

The platform expanded from a limited collection of datasets to a much broader municipal intelligence layer covering sources such as:

• DOB
• FDNY
• OATH/ECB
• ACRIS
• Housing-related records
• Certificates of Occupancy
• Boilers and elevators
• Safety violations
• Property records

This allowed users to investigate properties from a much more complete compliance perspective.

Better Property Discovery#

AKA and multi-BIN resolution reduced the risk of treating related NYC property identifiers as unrelated records.

More Reliable Background Processing#

Redis and Laravel Horizon moved expensive scraping and processing workloads away from synchronous requests and provided centralized queue monitoring and worker management.

Faster Frontend Experience#

Redux optimization and memoized selectors reduced redundant API requests and improved affected page-load workflows by more than 60%.

Real-Time Operations#

WebSockets, email and SMS workflows enabled users to receive and act on important compliance information without relying solely on manual property searches.

SaaS Commercialization#

Stripe subscriptions, seat-based access and SMS credits provided the application with a flexible foundation for recurring SaaS revenue.

Enterprise Collaboration#

Organizations, seats, permission scoping and property-level messaging turned the platform into a collaborative workspace rather than a single-user lookup tool.

My Engineering Contribution#

As the Lead Full-Stack Software Engineer, I worked across the entire product rather than owning only one layer.

My responsibilities included:

• Backend architecture and Laravel development
• React and Redux frontend development
• REST API design and implementation
• Municipal data ingestion
• Web scraping workflows
• DTO and data normalization architecture
• Redis and Laravel Horizon queue architecture
• GIS and Leaflet integration
• Sanborn map integration
• Real-time Pusher WebSocket functionality
• SMS and email notification systems
• Multi-tenant organization architecture
• Stripe and Laravel Cashier billing
• API authorization and feature gating
• Large-scale export processing
• Frontend performance optimization
• AWS-related infrastructure and observability

Across the project, I contributed to 1,180+ production commits spanning frontend, backend, scraping, queue workers, integrations and billing.

Engineering Takeaway#

Violerts was a strong example of taking a data-heavy MVP and evolving it into a production SaaS platform.

The most important engineering lesson was that the difficult part was not simply integrating another API or scraper. The real challenge was building a reliable system around unreliable external data sources, normalizing fragmented property identities, processing large workloads asynchronously, and turning that data into an experience that real estate professionals could act on immediately.

The result was a platform combining:

Municipal Data + Property Intelligence + GIS + Real-Time Alerts + Collaboration + SaaS Billing

into one workflow for NYC real estate compliance.