Fully managed websites for small businesses
Website, hosting, updates, SEO, local visibility, reputation management, and support—all handled by one accountable expert.
$299/month · $300 one-time setup · month-to-month
Public repositories, demos, and case studies showing architecture choices, operating constraints, and verifiable implementation results. This is the technical side of Mendola.Tech for clients, partners, and potential employers.
Repos and live work you can inspect instead of taking claims at face value.
Frontend, browser performance, networking, simulation, and lower-level architecture.
Managed client websites plus software and automation work behind operations.

Modern C++20 simulation framework with multithreaded job scheduling, custom ECS, and deterministic physics. Handles 10,000+ concurrent entities.
C++17 benchmarking suite for data structure performance analysis. Compares custom implementations across hardware platforms and compiler optimizations.
Some work cannot be published as source. These are representative technical areas where the same engineering approach applies.
Engineered autonomous agents for real-time market analysis using Deep Reinforcement Learning. Features predictive modeling, risk management, and high-frequency execution pipelines.
End-to-end decentralized finance platform with cross-chain bridges, mobile wallet integration, and gas-optimized smart contracts. Handles significant transaction volume.
High-performance simulation engine featuring A* pathfinding, custom ECS architecture, and deterministic physics. Optimized for large-scale agent simulations.
Secure document lifecycle management for enterprise clients. Features encryption at rest, audit logging, and compliance-ready architecture serving thousands of users.
Ten recent builds explained through the problem, implementation, verified result, evidence basis, and limits of what the available data can support.
The public launch needed to explain several related exterior home-improvement services without making homeowners decode trade terminology. Service details, Tampa Bay coverage, community reviews, and estimate requests also needed clear destinations instead of competing on one overloaded page.
Launched a focused managed website with dedicated routes for seamless gutters, pool screen enclosures, screen repair, soffit and fascia, and gutter guards. The information architecture also separates service areas, reviews, privacy information, and the estimate path so visitors can move from a specific need to a relevant next step.
The live site now gives each major service an indexable destination and connects the primary customer journeys to an estimate request. It also provides one maintained public reference for services and coverage instead of relying on disconnected descriptions elsewhere.
The public camokrewfl.com routes, Mendola.Tech client listing, saved launch screenshot, and August 2026 repository history can be inspected directly.
No claim is made about lead volume, rankings, revenue, or improvement over a previous site. Those outcomes require approved analytics and client confirmation.
A paid-search visit begins on mendola.tech but signup and onboarding continue on customer.mendola.tech. Campaign parameters, Google click identifiers, landing-page context, and purchase events can be lost or duplicated when that handoff is treated as an ordinary outbound link.
Implemented a shared GA4 property and cross-domain linker, forwarded UTM fields plus GCLID, GBRAID, WBRAID, and landing variant into the hash-routed signup, sanitized and stored those values server-side, and instrumented the funnel from signup through a transaction-ID-based purchase event.
Repository tests now verify the complete synthetic attribution payload on both sides of the handoff, require lead tracking only after a successful submission, and require purchase values to come from the recorded checkout amount and currency instead of a hard-coded number.
The website and customer-panel attribution suites use synthetic identifiers and inspect the production code paths without requiring a real advertising click.
This proves implementation continuity, not that GA4 or Google Ads will attribute every real conversion correctly. No campaign performance, conversion lift, or advertising return is claimed.
Public review data can arrive through different Google surfaces, service-area business discovery can be inconsistent, and a partial refresh must not silently replace a richer verified cache or inflate structured-data claims.
Built a Places API path using a configured Place ID, guarded fallback queries, and a browser extractor for public review pages. The pipeline preserves original customer wording, supports rating-only reviews, sanitizes provider failures, keeps richer cached data when a refresh is partial, and synchronizes visible review output with business schema safeguards.
Mendola.Tech now has a dedicated review page, reusable review components, visitor-safe fallback actions, and automated fixtures covering API normalization, public-page extraction, missing fields, lookup alternatives, and empty results.
The implementation is backed by saved HTML fixtures, API-response fixtures, UI tests, the public reviews page, and build-time review synchronization scripts.
The pipeline does not guarantee Google API availability, complete review retrieval, richer search results, or additional leads. Public review text remains attributed to its original author and source.
A managed service becomes confusing when its public price, signup language, disclosures, checkout, billing portal, and backend routes describe different versions of the offer. Removing an old option from one screen is not enough if another active surface still exposes it.
Aligned the active $299 monthly managed-website offer across the marketing site and customer panel, versioned the current disclosure, updated checkout and subscription handling, and removed obsolete add-on routes and controls. Cross-surface tests scan the active offer files for the current terms and for stale pricing or retired options.
The active customer journey now presents the same base offer through pricing, signup, disclosure acceptance, checkout, and billing management. Automated checks fail when an outdated $199 price or removed add-on reappears in those covered surfaces.
The evidence is the active pricing and onboarding code, versioned disclosure files, billing handlers, and customer-panel pricing-and-analytics test contract.
Consistency is verified only for the repository surfaces included in the contract. No purchase-rate, revenue, retention, or customer-satisfaction improvement is claimed.
Organization-specific analytics and local-presence data need delegated Google access, but OAuth credentials and refresh tokens cannot be pushed into frontend code. Customers also need understandable states when a property is unselected, an API is unconnected, or Google has not approved enough quota.
Added server-owned OAuth configuration, connection records, callback and management handlers, organization-level admin controls, GA4 reporting ranges, and Google Business Profile surfaces. The frontend receives status and permitted results while client secrets remain server-side, and provider failures are translated into clean precondition or quota messages.
Administrators can manage Google connections for an organization and request the enabled analytics or business-profile views through one permissioned integration boundary. Tests verify the connection surfaces and confirm that the configured OAuth secret does not appear in frontend assets.
The customer-panel repository contains the setup guide, integration service and handler tests, connection models, admin pages, and secret-boundary assertions.
The case study does not expose account identifiers, tokens, private analytics, or Business Profile data. API availability, quotas, and returned fields remain controlled by Google.
A customer portal needed employee access, organization assignment, and sales attribution without sending staff through customer onboarding or treating current account ownership and original sales credit as the same relationship.
Built a dedicated tokenized employee invitation and signup path, an access-management console, a reusable employee directory, assignment and sales-credit selectors, and separate organization fields for the assigned employee, seller, and close date. Conversion logic fills missing organization attribution while keeping the organization as the durable record.
The platform now models ongoing responsibility independently from sales credit and keeps employee account creation outside billing and customer onboarding. Tests cover navigation, tokenized signup, access promotion and removal, directory-backed selectors, and pay-period reporting fields.
The implementation is documented in the customer-panel README and exercised by employee-management, CRM scope, handler, model, and router tests.
No employee names, compensation values, customer assignments, or productivity outcomes are published. The study covers access and data modeling, not an independent payroll audit.
A third-party backlink provider can expand discovery, but its live and lost labels are external claims rather than proof. Credentials, pagination, retries, daily spend, response size, and incomplete snapshots also create operational risks if the integration is allowed to write directly into local truth.
Built one backend-only DataForSEO client with HTTPS and endpoint restrictions, bounded timeouts and response size, finite pagination, idempotent-read retries, persisted request and cost ceilings, and safe structured errors. Provider claims are stored separately, deduplicated as candidate edges, and passed to an independent source-page verifier before local state changes.
The platform can use bounded provider snapshots to widen discovery without letting an omitted or provider-lost record directly mark a link as locally lost. Persisted usage accounting and per-run and per-day limits stop additional requests after configured ceilings are reached.
The private SEO repository includes the integration contract, architecture notes, migrations, provider fixtures, transport tests, usage-accounting tests, and deployment validation.
No provider completeness, accuracy, cost efficiency, or backlink-growth result is claimed. DataForSEO behavior, limits, and pricing must be rechecked against current vendor documentation.
Historical links can disappear from a current provider snapshot while remaining discoverable in public archives, crawl graphs, or first-party referral records. The same target may also have moved between apex and www hosts, so searching only one hostname can miss relevant evidence.
Built separate discovery lanes for Common Crawl, Wayback history, host-graph data, and GA4 referral target pages; normalized apex and www target identities; preserved source-specific evidence; and sent recovered candidates through exact target matching and live source-page verification.
The recovery workflow can reintroduce historical candidates from either host form without treating archive absence as proof that a link never existed or is currently lost. Tests cover dual-host resolution, archive metadata, compressed index ranges, and candidate handoff boundaries.
Repository history contains the host-resolution tests, archive and graph adapters, GA4 target-page recovery work, and dated production-proof notes for the individual lanes.
Public corpora and analytics histories are incomplete. No recovery rate, total-link count, or universal coverage claim is made without a dated, approved target dataset.
Long-running crawls and archive workers can be interrupted by API restarts, deployment changes, network failures, or resource pressure. Leaving those runs marked as active, replaying completed work, or losing every worker's progress makes later reports difficult to trust.
Added durable run and job states, leases, idempotency keys, independent worker checkpoints, bounded concurrency, disk reserves, recovery routines, and explicit restart handling for crawl, backlink, graph, archive, and news-ingestion lanes. Recovery behavior is tested separately from completed terminal records.
The database-backed recovery test proves that an interrupted crawl and its job are closed once with an explanatory event, a completed crawl is left unchanged, and repeating recovery is a no-op. Other pipeline lanes preserve checkpoints so restart work can resume from durable boundaries instead of beginning blindly.
The SEO repository includes recovery migrations and stores, database integration tests, worker checkpoint tests, operations runbooks, and dated restart-proof records.
These controls reduce ambiguous state; they do not guarantee uninterrupted service, zero duplicate external requests, or a particular throughput. Quantitative resilience claims require a controlled failure-injection benchmark.
A React site needed a maintainable research workflow in which one approved article record controls the visible page, canonical metadata, Article schema, RSS item, sitemap date, prerendered route, and internal links while unapproved drafts remain outside every public surface.
Built a validated Markdown contract, separate draft and published collections, sanitized rendering, generated React records and routes, canonical and Article metadata synchronization, RSS and sitemap generation, static prerendering, and negative tests that assert draft slugs never enter routes or feeds.
The August 2026 deployment published three approved research articles, generated 28 prerendered site routes and 24 sitemap URLs, and kept three additional drafts at 404 responses and out of RSS and the sitemap. The repository's 27-test suite and GitHub Pages build passed before deployment.
The public blog, RSS feed, sitemap, dated prerender comparison, content generator, route metadata, and CI test suite are all available for inspection.
The implementation proves publication-state isolation and generated-output consistency. It does not prove indexing, rankings, traffic, citations, or backlink acquisition.
Additional architecture, tradeoffs, and implementation outcomes from public and anonymized private work.
A service business needed one place to collect onboarding details, manage organizations, handle support requests, expose customer documents, and keep internal admin work from turning into scattered email threads.
Built a Go-backed customer panel with organization-aware routing, onboarding steps, billing handoff, support tickets, document access, admin queues, and frontend permission helpers. Added deployment validation, frontend smoke tests, and cache-busted static assets so customer-facing changes ship predictably.
Turned the managed-website service into an operational system: signup, intake, support, and internal follow-up now share one workflow instead of relying on manual coordination.
Field-oriented work needs fast capture, durable state, and clear handoff between the person doing the work and the backend system that tracks progress, status, and history.
Built a Kotlin-first mobile workflow backed by Go services and PostgreSQL routines. Kept the domain model explicit so jobs, statuses, and transitions can be reasoned about across app and server boundaries.
Created a practical pattern for mobile-first operational software: the phone becomes the front line for capture while backend services preserve the source of truth.
Managed websites need repeatable technical checks without turning every audit into a manual browser session: metadata, page structure, broken links, indexability, and deployment regressions all need a consistent review path.
Built Go-based crawl and reporting tooling with a lightweight browser UI, shell automation, and static output paths. The crawler focuses on repeatable checks that can be rerun after content or deployment changes.
Reduced technical SEO review from an ad hoc checklist to a reusable workflow that supports maintenance, launch checks, and client-site quality control.
Sensitive document workflows need a safer structure than shared drives or email attachments: access, ownership, family sharing, and lifecycle state all have to be modeled carefully.
Built a React and Go platform around secure document storage, account-level workflows, and controlled sharing. Treated permissions and data boundaries as product features instead of afterthoughts.
Produced a private MVP architecture for high-trust document workflows where the main engineering risk is not rendering pages, but protecting state transitions and access paths.
A real-time strategy prototype needed synchronized multiplayer without trusting every client input, while keeping the simulation deterministic enough for fair wave-spawn gameplay.
Designed a Godot 4 multiplayer architecture around deterministic lockstep updates, Steamworks multiplayer integration, commit-reveal input validation, polymorphic unit behavior, and automated GUT coverage for gameplay systems.
Established a testable multiplayer foundation where fairness, determinism, and unit-system flexibility are explicit constraints instead of late-stage patches.
Trading and analytics experiments require repeatable data collection, derived signals, backtesting or review surfaces, and guardrails so automation does not become an opaque black box.
Built Python-heavy tracking and bot tooling with web output, containerized runtime paths, and explicit separation between data collection, analysis, and execution-facing logic.
Created a reusable pattern for private analytics systems: collect consistently, inspect the intermediate state, and keep execution decisions isolated from raw scraping or signal generation.
Building a full 3D isometric action-RPG that runs smoothly in web browsers—including mobile devices—without native code or plugins.
Built with Three.js using a chunk-based streaming architecture—only loading and updating entities within the player's active 3x3 chunk grid. Optimized GLTF assets to 500-2k triangles per model. Implemented instanced rendering for repeated objects, frustum culling, and draw call batching to keep GPU overhead minimal.
Achieved consistent 60 FPS target on desktop and mobile browsers with smooth gameplay and responsive controls.
Initial multiplayer implementation sent complete world state to every connected player on each tick, causing bandwidth to scale linearly with player count and limiting concurrent sessions.
Rewrote the Go server to track per-player entity snapshots and transmit only changed fields. Added GZIP compression with pooled writers to eliminate allocation overhead. Prioritized updates by proximity—nearby entities update at 20Hz, distant entities at 5Hz.
Reduced per-player bandwidth by ~80%, increasing theoretical player capacity from ~50 to ~250 concurrent players on the same server hardware.
Naïve collision detection checked every entity against every other entity—O(n²) complexity that degraded rapidly as world population grew beyond 100 entities.
Implemented a spatial hash grid partitioning entities into 50-unit cells. Collision queries now only check entities in adjacent cells. Added separate tracking for movable vs static entities to skip unnecessary recalculations.
Collision detection dropped from O(n²) to O(n), supporting 500+ simultaneous entities with sub-millisecond query times.
Needed thousands of unique items without hand-crafting each one, while ensuring loot felt rewarding at every level and preventing stat inflation from breaking balance.
Built a composable item generator with base types, rarity tiers, and affix pools. Stats scale via formulas tied to item level and rarity multipliers. Rarity distribution uses weighted random selection (Common 50%, Rare 30%, Epic 15%, Legendary 5%).
System generates 10,000+ unique item combinations. Level 1 and level 50 items feel proportionally powerful without manual tuning per tier.
Party features (health bars, positions, shared XP) required frequent updates, but broadcasting to all connected players wasted bandwidth and leaked information.
Implemented party-scoped message channels. Party state changes broadcast only to party members via ID lookup. Added leader transfer on disconnect and automatic disband when empty.
Party updates use <1% of total bandwidth. Supports unlimited concurrent parties with zero cross-party data leakage.