DEV Community: Thejan Vishmitha

FindLand: Reviving a Map-Based Land Selling Platform into a Live Production Product

Thejan Vishmitha — Wed, 03 Jun 2026 00:29:47 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built FindLand, a map-based land selling platform designed to make land discovery easier, faster, and more visual.

FindLand was created to solve a practical problem in the land and real estate market. Many property platforms depend mainly on long listing pages, repeated text, and static property cards. For buyers, this can make it difficult to understand where a land is located, what is around it, and whether it matches their actual needs.

With FindLand, the map becomes the center of the experience.

Instead of forcing users to scroll through endless listings, FindLand allows buyers to visually explore land opportunities through an interactive map. Users can browse lands by location, view important details quickly, filter listings, and open detailed land pages before contacting the seller.

The platform includes:

Interactive map-based land discovery
Land markers connected with listing details
Search and filtering options
Land listing cards with key buyer information
Detailed land view pages
Seller contact flow
Responsive design for desktop and mobile users
A production-focused structure that can grow with future features

FindLand is meaningful to me because it is not just a practice project. It is a real production-level application built around a real market need. The goal is to make land discovery more visual, more practical, and easier for local buyers and sellers.

Demo

Live Project: https://findland.lk
Production Source Code: Private

FindLand is currently a live production platform. Because it is a commercial application, the full production repository is private and not publicly shared. It contains business logic, admin workflows, security-sensitive implementation details, and proprietary platform features.

For this challenge, I am sharing the live product, screenshots, walkthrough, and a public showcase repository. If official challenge reviewers need to inspect the code, I can provide limited access or a guided code walkthrough upon request.

Screenshots

The homepage introduces FindLand as a map-based land discovery platform and gives users a clear starting point to explore available lands.

The main marketplace experience allows users to discover lands visually through an interactive map instead of only depending on traditional listing pages.

FindLand is responsive, allowing users to explore land listings from mobile devices as well as desktop screens.

The Comeback Story

FindLand started as a bigger idea for a land selling platform. The original goal was to build a complete property marketplace with land listings, seller tools, buyer discovery features, admin controls, and map-based browsing.

The idea was strong, but the scope was too broad in the beginning.

Because of that, the project stayed unfinished for some time. There were many possible features to build, but the most important question was:

What should the first complete version focus on?

For the GitHub Finish-Up-A-Thon Challenge, I decided to bring the project back with one clear goal:

Complete the core map-first land discovery experience.

Instead of trying to finish every possible marketplace feature at once, I focused on the part that makes FindLand different: helping users discover lands visually through a map.

During this comeback, I focused on improving and completing:

The overall product direction
The buyer-side land discovery flow
Map-based browsing
Listing presentation
Search and filtering experience
Land detail page structure
Responsive layout
Public-facing user experience
Production deployment

This changed FindLand from an unfinished idea into a live production application.

The biggest lesson from this process was that finishing a project is not always about adding more and more features. Sometimes, finishing means reducing the scope, focusing on the strongest idea, and polishing the core experience until the product becomes useful and understandable.

FindLand became much stronger when I focused on its main value:

Land discovery should be visual, location-first, and simple for users.

My Experience with GitHub Copilot

GitHub Copilot helped me move faster during the finishing process by supporting development, refactoring, and documentation tasks.

While building and polishing FindLand, Copilot was helpful for generating starting points, improving repeated code patterns, and suggesting cleaner ways to structure parts of the project. It helped me work more efficiently, especially when dealing with UI components and repeated logic.

Copilot supported me with:

Component structure suggestions
UI layout improvements
Reusable code patterns
Filtering logic ideas
Form handling patterns
Code cleanup and refactoring
Documentation and README structure
Faster iteration during development

However, Copilot did not replace product thinking. The main decisions, user experience, platform direction, and business logic were planned and reviewed manually. I used Copilot as a development assistant, not as an automatic decision-maker.

The most useful part of Copilot was speed. It helped reduce repetitive work and gave me useful starting points, but I still reviewed, adjusted, and improved the code to match the actual requirements of FindLand.

This challenge reminded me that unfinished projects usually do not fail because the idea is bad. Many times, they remain unfinished because the scope is unclear. Once I focused on the most important part of FindLand, the project became easier to complete and easier to explain.

Now FindLand is live at https://findland.lk, and it has a clear foundation for future improvements.

Final Thoughts

FindLand started as an unfinished land marketplace idea and became a live map-based land selling platform.

Through this challenge, I was able to look at the project again, reduce the scope, polish the core experience, and move it into production.

This project means a lot to me because it is not only a coding project. It is a real product with real potential.

The next steps for FindLand include improving seller tools, enhancing listing verification, adding more discovery features, improving user trust, and continuing to make land buying easier through better technology.

FindLand is still growing, but now it is no longer just an idea.

It is live.
It only support for Sri Lankan Market but it will support for more countries as soon as possible

PR Whisperer: A Copilot-Powered CLI for Writing Better Pull Requests

Thejan Vishmitha — Fri, 30 Jan 2026 18:23:27 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built PR Whisperer (prw), a command-line tool that helps developers write better pull requests using GitHub Copilot CLI.

Instead of being “AI for the sake of AI”, PR Whisperer focuses on real developer workflows:

reviewing your own changes objectively
generating clear, structured PR descriptions
working even when you’re not on a feature branch

The goal was to make Copilot feel like a thoughtful PR partner rather than just a text generator.

PR Whisperer supports multiple review contexts:

traditional PRs (branch vs base)
pre-commit reviews (staged changes)
same-branch workflows (last commit vs previous commit)

All from the terminal, with zero browser context switching.

Demo

Repository:

https://github.com/HarryVishmitha/prw-whisper

Example commands:

prw doctor
prw review --commit --save
prw describe --commit --save
prw init

What happens when you run it

prw review generates a structured PR review (summary, risk, issues, suggestions, checklist)
prw describe drafts PR titles and a clean GitHub-ready PR description
--save writes Markdown reports to .prw/reports/
prw init runs copilot init and generates repository instructions automatically

Screenshots and CLI output examples are available in the repository README.

Sample Screenshots

My Experience with GitHub Copilot CLI

This project was built around GitHub Copilot CLI — not just with it.

I used Copilot CLI in three intentional ways:

AI-powered reviews

Copilot analyzes Git diffs and generates structured, human-readable PR feedback.
PR description generation

Copilot drafts PR titles and PR descriptions using a consistent template

(What / Why / How / Testing / Risk).
Repository initialization

prw init wraps copilot init to generate .github/copilot-instructions.md, documenting architecture, conventions, and CLI behavior.

I intentionally avoided calling Copilot when it wasn’t needed:

PR Whisperer detects “no diff” scenarios and guides the user instead of wasting AI calls
All Copilot usage is non-interactive and scripted, making it reliable and repeatable

This made Copilot feel less like a chatbot and more like a well-integrated CLI collaborator.

Why This Project Is Different

Most PR tools assume:

“You always work on feature branches.”

PR Whisperer supports:

solo developers
same-branch workflows
pre-commit reviews
quick self-reviews before opening a PR

It’s not flashy — it’s practical, and designed to fit into how developers actually work.

Final Thoughts

Building PR Whisperer showed me that the real strength of GitHub Copilot CLI isn’t just code generation — it’s augmenting developer judgment.

This project reflects how I’d genuinely want to use Copilot in my own workflow:

intentional
context-aware
respectful of developer time

Thanks for the challenge — this was a great opportunity to explore what AI-powered CLI tools can really be.