Skip to content

Railway Graph Polyline Editing Utility — architecture review

This page assembles sections relevant to architecture review: goals, requirements, and constraints; system model; architecture and integrations; security, quality, and operations; and decisions, trade-offs, and risks.

Contents

Summary

Status

historical internal project / evolved into GraphMechanic concept

Role

initiator, concept author, developer

Stack

Type: Internal tooling / GIS data preparation / railway graph editing

Project value

A local web utility for creating, editing, and repairing railway track polylines used in railway graph data preparation.

What this demonstrates

This project demonstrates my early transition from requirements and data preparation work toward hands-on internal tooling development.

It shows the ability to:

  • identify a repetitive data preparation bottleneck;
  • convert a manual GIS/data-cleanup task into a visual tool;
  • design a pragmatic internal application for a narrow operational problem;
  • combine backend logic, map UI, routing, caching, and asynchronous interactions;
  • create tools that reduce manual work and improve data quality.

The project later evolved conceptually into GraphMechanic, a broader idea for visual graph editing and GIS-related data tooling.

Goals, Requirements, and Constraints

Goals and Non-Goals

Requirements

I designed and implemented a local web utility for railway graph polyline editing.

The tool supported:

  • viewing railway graph objects on a map;
  • editing graph nodes;
  • creating new polylines;
  • applying changes without full page reloads;
  • preparing graph data for further use in GIS-related systems.

Constraints

System Model

Domain Model

Data Model

API Contracts

Architecture and Integrations

Architecture

Architectural Approach

The utility was implemented as a layered monolithic web application.

The architecture included:

  • server-side page rendering;
  • MVC structure;
  • business logic layer;
  • repository layer;
  • jQuery-based interactions for partial updates without full page reloads.

Integration Flows

Polyline generation via routing service

The tool generates polylines through a routing service, producing route-based geometry for railway graph segments.

Polyline repair via route recalculation

Existing polylines can be repaired through route recalculation when geometry is incorrect or incomplete.

Asynchronous polyline loading and update flows

The application supports asynchronous polyline retrieval and update flows, including polyline caching, enabling partial UI updates without full page reloads.

Security, Quality, and Operations

Security and Access Model

Non-Functional Requirements

Failure Modes

Sizing and Cost Notes

Decisions, Trade-offs, and Risks

Key Decisions

Trade-offs

Pragmatic local-only design

This approach was intentionally pragmatic: the tool was designed for local/internal use, fast iteration, and practical data preparation rather than long-term productization.

See also Architecture Decision Records.