Modernization of Violerts - NYC PropTech Compliance Platform
Aqib Javaid
Real-time compliance intelligence for NYC real estate professionals.
Violerts is a PropTech SaaS platform that consolidates fragmented NYC municipal property data into a single compliance intelligence platform. I led the modernization of the React frontend and Laravel backend, building multi-agency data ingestion, GIS mapping, asynchronous scraping, real-time alerts, team collaboration, and Stripe-powered SaaS billing.
Client
Sep 2025
Daniel Lee
Project Manager, AZARK
Daniel Lee profile photo
Daniel Lee
Project Manager • AZARK
“Great developer to work with, very knowledgeable”
Confidential Enterprise Project (Protected Under NDA)
Proprietary source code, database architectures, and internal endpoint credentials are confidential. This case study highlights non-proprietary architectural patterns, technical solutions, and verified outcomes.
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.
The resulting architecture separated the application into several major responsibilities:
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.
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.
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.
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
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.
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.
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:
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.
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.
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.
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.
A property could appear under multiple addresses, BINs or tax lots. Looking up only one identifier could result in incomplete compliance information.
I implemented an address-resolution workflow around NYC GOAT data and related property identifiers.
The process became:
This significantly improved the platform's ability to associate municipal records with the broader property identity.
Municipal systems can be slow and unpredictable. Large responses could cause memory exhaustion or gateway errors when processed synchronously.
I redesigned the ingestion workflow around background processing.
Instead of:
the architecture became:
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.
The platform needed to support organizations with multiple users while maintaining appropriate access boundaries.
A simple user-to-property relationship was no longer sufficient.
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.
The engineering work transformed Violerts from a basic property lookup application into a broader compliance intelligence platform.
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.
AKA and multi-BIN resolution reduced the risk of treating related NYC property identifiers as unrelated records.
Redis and Laravel Horizon moved expensive scraping and processing workloads away from synchronous requests and provided centralized queue monitoring and worker management.
Redux optimization and memoized selectors reduced redundant API requests and improved affected page-load workflows by more than 60%.
WebSockets, email and SMS workflows enabled users to receive and act on important compliance information without relying solely on manual property searches.
Stripe subscriptions, seat-based access and SMS credits provided the application with a flexible foundation for recurring SaaS revenue.
Organizations, seats, permission scoping and property-level messaging turned the platform into a collaborative workspace rather than a single-user lookup tool.
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.
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.
Gallery
copilot 20260820 195038
Tech stack
Timeline & Milestones
Audited the existing MVP architecture, identified data coverage gaps, scraping bottlenecks, frontend performance issues and missing SaaS capabilities
Built new datasets, AKA/multi-BIN resolution, DTO pipelines, scraper workflows, Laravel APIs and Redis/Horizon background processing
Added Leaflet mapping, Sanborn map workflows, real-time property collaboration, SMS/email notifications and large-scale export processing
Implemented organizations and seats, Stripe subscriptions, feature gating, frontend optimization, queue separation and operational improvements
Outcomes & Impact
Municipal Data Coverage
Expanded the compliance intelligence layer across DOB, FDNY, OATH, ACRIS and other municipal sources
Frontend Performance
Reduced redundant API requests and optimized Redux state transitions with memoized selectors
Production Engineering
Delivered continuous full-stack development across React, Laravel, scraping, GIS, queues and billing
Processing Reliability
Isolated heavy scraping, notifications and exports into Redis-backed asynchronous workloads
Technical Insights
Related Architecture & Engineering Articles
The Hidden Value of Senior Developers: Why Experience Beats Low-Cost Outsourcing
Hiring the cheapest developer can reduce your initial development cost, but it can also increase maintenance, technical debt, and long-term engineering costs. Here’s why experienced PHP and Laravel developers often deliver better value over the life of a product.
How a Laravel Consultant Keeps Projects Transparent
Clients don't just need a Laravel developer who can write code. They need confidence that their project is progressing, risks are being managed, and sensitive data is protected. Here's how I approach transparency, communication, documentation, and security when building Laravel applications.
A production deployment problem exposed deeper infrastructure issues. Here’s how I diagnosed the system, fixed the root causes, and made deployments safer.
API Idempotency Keys: Stopping Duplicate Writes in Laravel
A retried POST request isn't a safe assumption — it's a duplicate charge waiting to happen. Here's how idempotency keys make retries actually safe.
Redis Caching Architecture for Laravel SaaS at Scale
A cache with no invalidation story isn't a performance win. It's stale data waiting to embarrass you in front of a customer.
A real-world look at how I designed a resilient web scraping system for Violerts to collect, normalize, and manage data from complex government sources.
Real-Time Features in Laravel SaaS: Architecting Broadcasting and WebSockets That Hold Up in Production
A live dashboard that works for one user in a demo is easy. One that works for 500 users across tenants, through a dropped connection, is the real engineering problem.
Testing Strategy for Laravel SaaS: PHPUnit, Dusk, Load Tests
A passing CI pipeline and a production incident can coexist. Here's the Laravel testing architecture that closes that gap for real SaaS teams.
How I design change detection for scraped data: stable record identity, normalisation, content hashing, field-level diffs and alerts users trust, with Laravel and MySQL examples from a real NYC compliance monitoring platform.
API Rate Limiting & Throttling in Laravel SaaS
One global throttle:60,1 works until a single client integration hammers your API and takes every other tenant down with it.
WHERE title LIKE '%term%' works until customers expect search that's fast, relevant, and never leaks another tenant's records.
A practical comparison of Laravel and Node.js for building a SaaS backend: time to launch, built-in features, real-time needs, hiring, hosting and maintenance, with examples from real SaaS products built on each.
A practical Laravel upgrade checklist for old apps: what to check before you start, how to upgrade one major version at a time, how to test, and how to deploy with a rollback plan.
A plain comparison of Laravel hosting options and cost: Forge, DigitalOcean, AWS and Laravel Cloud, with the hidden extras and a five-question way to choose.
Is web scraping legal for business? Learn when scraping is lower or higher risk, how terms of service, personal data, copyright and robots.txt matter, and a checklist to use first.
MLS and IDX Integration: A Guide for Real Estate Platforms
MLS and IDX integration explained: how listing data feeds work, what licensing you need, the architecture to use and the pitfalls to plan for before you build.
AI features can quickly turn a clean Laravel application into a maintenance nightmare. Here's how to integrate AI without sacrificing architecture.
A practical Laravel slow queries fix: how to find the queries that hurt, read what MySQL says about them, and fix the five most common causes with before-and-after proof.
A founder-friendly comparison of React Native vs Flutter for an MVP: what each is, where each wins, what really drives cost, and a simple way to decide.
A practical checklist for hiring a senior Laravel developer: what senior really means, what to check before interviewing, questions that reveal production experience, a fair practical test and the red flags to watch for.
Like this project
Posted Oct 15, 2026
Led modernization of PropTech SaaS platform, improving scalability and functionality.
Likes
0
Views
1
Timeline
Sep 1, 2025 - Ongoing
