EDS Group

Engineering a real estate platform from data to deployment.

Next.jsTypeScriptSharpDockerCaddy11 min read
Live website
9:41 edsarh.ru
EDS residential development page on mobile
The mobile composition keeps the development story readable without shrinking the desktop interface.

I engineered the EDS website from its public interface through the data pipeline, image processing, backend security, and production deployment. The visual direction came from a separate designer; my role was to turn it into a complete, maintainable application.

The Challenge

EDS needed one digital platform for residential developments, available apartments, floor plans, mortgage programs, company information, and customer inquiries. The challenge extended beyond the interface: property data had to stay consistent across multiple pages, architectural imagery needed careful optimization, and public forms required secure server-side processing.

The initial apartment catalog already existed as structured data. Its publishing workflow did not yet require a database, CMS, or continuous external feed. Introducing those systems immediately would have increased infrastructure complexity without addressing an operational need.

I chose a static-first architecture. Property data and images are prepared during the build, public pages are pre-rendered, and the production server handles only the operations that need request-time processing. This created a controlled path to production while preserving clear integration points for future data feeds or administrative tools.

  • Client: EDS Group, real estate developer
  • Role: frontend, backend, data processing, and DevOps
  • Design: supplied by a separate designer
  • Infrastructure: Docker Compose, Caddy, and a Linux VPS

Product & Data

Visitors reach the platform through development pages, apartment listings, galleries, floor plans, mortgage programs, and contact forms. Each experience has a different purpose, but all of them need to work as one consistent product.

I developed reusable application components and responsive layouts that preserve a shared visual and structural language. Rather than assembling apartment pages by hand, property records follow a common data model and rendering process. That keeps the presentation consistent as the catalog grows and reduces page-specific implementation.

9:41 edsarh.ru
EDS homepage and property catalog
The public catalog opens with the same hierarchy on every screen, without compressing the mobile view into a desktop crop.

The apartment catalog is maintained in structured JSON. Before Next.js generates pages, a custom importer validates property identifiers and development relationships, prices and floor areas, availability, required fields, and overall data consistency.

TypeScript provides compile-time checks throughout the application, but external JSON needs another layer of protection. The importer validates the actual catalog before it becomes part of the application. If a record fails validation, the build stops rather than publishing an incomplete or incorrect property page.

Source

JSON catalog

Validate

Runtime schema

Normalize

Application model

Generate

Static routes

Invalid catalog data stops the build before public routes are generated.

The validated catalog is transformed into application models and used to generate public routes. The measured production build contains 85 statically generated pages and three runtime API endpoints for callbacks, feedback, and health checks. Ordinary browsing stays independent of request-time catalog processing.

There is a deliberate trade-off: apartment price or availability changes currently require a new build. For the existing workflow, that is acceptable. If the catalog later needs frequent external updates, the importer is the integration boundary for an API, database, or administrative interface without rebuilding the presentation layer.

85

Generated public pages

Built ahead of requests

3

Runtime API routes

Callbacks, feedback, health

Performance & Imagery

Real estate products depend heavily on visual content. Architectural renders, galleries, and floor plans must remain detailed enough for real purchasing decisions, especially where small labels, dimensions, and architectural features matter. At the same time, oversized files create a delivery cost.

I implemented a custom Sharp pipeline before the Next.js production build. JPEG and PNG sources become responsive WebP variants, with JPEG or PNG fallbacks where appropriate. The standard widths are 480, 640, 768, 1024, 1280, 1600, and 1920 pixels, and images are never upscaled beyond their source resolution.

Engineering Challenge: Image Quality vs. Performance

One challenge emerged during mobile testing. The initial image-processing configuration prioritized smaller file sizes, but aggressive compression introduced visible artifacts on high-density mobile displays. Architectural details and fine textures appeared less consistent than on desktop.

I adjusted the Sharp processing configuration to preserve more image detail, accepting larger assets where visual quality mattered.

Increasing image quality introduced a trade-off in asset size. A subsequent mobile Lighthouse audit recorded a Performance score of 67, highlighting the importance of balancing visual fidelity with delivery efficiency.

The final approach combines build-time image processing, responsive image variants, pre-rendered public pages, and selective loading priorities.

Solaris screenshot

Responsive output

1024px target

The focal point stays stable while the generated source changes with the viewport.

Input
JPEG or PNG
Process
Sharp at build time
Output
Responsive WebP + fallback

Not every image can be processed in the same way. Architectural renders prioritize visual quality and efficient delivery, while floor plans need special care for fine lines, room labels, and measurements. Floor plans use more conservative settings and can retain an additional source-width variant where needed.

Each output file has a SHA-256-based fingerprint derived from the original asset and its processing configuration. Generated manifests hold dimensions, aspect ratios, widths, formats, and paths. A reusable Picture component turns that metadata into responsive picture, srcset, and sizes markup.

9:41 edsarh.ru
EDS apartment detail page
Apartment details use a dedicated responsive layout while keeping the essential decision data close to the top.

The apartment detail experience has a dedicated responsive layout, keeping important property information accessible without forcing mobile visitors through a compressed desktop composition. Above-the-fold images can load eagerly with higher fetch priority, while secondary media is lazy-loaded. The gallery prepares images around the active slide, and mobile does not mount an unused desktop slider.

The mobile Lighthouse result is shown as an audit snapshot, not as a claim about real-user performance. A separate local test reported LCP around 0.5 seconds, shown separately because local measurements are not production field data. The site did not yet have sufficient Chrome UX Report data for a reliable field-performance assessment.

Mobile Lighthouse, November 7, 2026. The local LCP result is shown separately because it is not field data.

67

Performance

94

Accessibility

100

Best Practices

100

SEO

~0.5s local LCP. Shown separately because it is not production field data.

Backend & Security

While property data is processed during the build, public forms create a different set of requirements. The platform accepts callback requests, apartment inquiries, and feedback submissions with optional image attachments. Client-side validation improves usability, but it cannot establish trust. Every important constraint is enforced again on the server.

Each IP address is limited to five submissions within ten minutes. Callback JSON bodies are limited to 16 KB. Feedback supports up to five images, with a combined limit of 10 MB inside a 12 MB multipart request. Caddy enforces the outer request-size boundary before the request reaches Next.js.

Request

Browser input

Rate limit

5 / 10 min

Validate

Body and files

CAPTCHA

Server check

SMTP

Notification

Accepted input reaches SMTP after each server-side gate.Failure paths

The path can stop at several points. File extensions, declared MIME types, and actual file signatures must agree. SmartCaptcha tokens are validated on the server with a bounded timeout; invalid verification never reaches SMTP.

Only requests that pass the required checks become escaped HTML and plain text for Nodemailer. Connection and socket timeouts prevent indefinite waits. Acceptance by the SMTP server is not treated as proof that a message reached the recipient's inbox. On failure, the API returns an error and the browser preserves the form data for retry.

The application intentionally has no submissions database or persistent delivery queue. Email is the operational destination, and the in-memory rate limiter is appropriate only for the current single-instance deployment. Multiple instances or stronger delivery guarantees would require shared rate-limit storage, durable submissions, and queued processing.

Infrastructure & Delivery

The production environment consists of one Next.js standalone container on a Linux VPS. Docker Compose manages the application lifecycle, while Caddy handles HTTPS, reverse proxying, and request-size restrictions. This keeps the deployment reproducible and straightforward to maintain without unnecessary orchestration.

I developed a release script that joins application preparation and production deployment. It generates responsive images, imports and validates the catalog, compiles the application locally, packages the Docker image, transfers it, replaces the running container, and waits for health verification. Nothing reaches production until local preparation succeeds.

Prepare

Local build

Package

Docker image

Deploy

VPS container

Verify

Healthcheck

A healthy replacement completes the release.Failure paths

A failed local build stops the deployment before transfer, leaving the existing production container untouched. After replacement, the script waits for health verification and provides recent container logs when startup cannot be confirmed.

Docker uses the unless-stopped restart policy, allowing an exited application process to restart automatically. The healthcheck runs every 30 seconds, but an unhealthy status does not automatically trigger a restart under Docker Compose.

The current deployment does not implement automatic rollback, blue-green releases, or guaranteed zero-downtime updates. A failed replacement may require manual recovery, and the single VPS remains a single point of failure. For the project's current scale, this is a conscious compromise between operational simplicity and infrastructure complexity.

Engineering Decisions

The architectural decisions follow one principle: move work to the stage where it can be controlled, validated, and repeated reliably. Catalog data is checked before deployment, images are transformed during the build, and static pages serve known content without request-time database queries.

Form submissions remain server-side because they cross trust boundaries and depend on external delivery. The release path adds reproducibility and health verification without introducing infrastructure the application does not need today.

Each choice carries a trade-off: static content requires rebuilding when data changes, a single server cannot provide high availability, and email delivery is not durable. Those limits are explicit and aligned with the current operating model.

The interface is the visible end of that system.

Outcome

The result is a publicly accessible real estate platform connecting EDS residential developments, apartment catalog, galleries, mortgage information, company content, and customer inquiry workflows. Visitors can explore properties through a consistent responsive experience while the application keeps a structured approach to content generation, image delivery, and request processing.

The production implementation includes 85 statically generated public pages, three runtime API endpoints, seven responsive image widths, and one controlled deployment path to production. Each replacement container is verified through a 30-second healthcheck cycle.

The architecture preserves integration points for future catalog feeds, administrative tools, durable submissions, or more advanced infrastructure without presenting them as already implemented. For EDS's current needs, it provides a complete public-facing experience without unnecessary operational complexity.

  • 85 generated public pages
  • Three runtime API endpoints
  • Seven responsive image widths
  • One controlled release path to the VPS

Next case study

Services Marketplace