Available for senior roles and selected projects

Drilon Bardhi, senior full stack developer in London

I turn “what if” into “it’s live”.

For more than ten years I’ve taken products from a sentence on a whiteboard to software people use every day. I build the interface, the API and the data model, then see it through release. I started in security testing and QA, so I build for how software fails.

Drag or swipe horizontally to rotate. Release to return. Tap to spin. Motion preferences apply.

Drag to turn. Tap for a spin.

Experience
10+ years
Background
Cyber security and software QA
Core stack
TypeScript, React, Next.js, Node.js, PostgreSQL
Based in
London, working with teams anywhere

Shipped work.

A live product built as a team with Lewis Morris, and a platform I built for an estate agency.

Live product, built as a team

DealGrade

Property risk, made clearer.

Lewis Morris and I built DealGrade together. It’s a property deal checker for investors in England and Wales: explore a DG Score, see the risk breakdown and stress-test cashflow before committing.

The team

CTO
Lewis Morris
Senior developer
Drilon Bardhi
  • Explainable scoring
  • Five risk categories
  • Cashflow stress tests
Visit dealgrade.co.uk (opens in a new tab)
DealGrade homepage with an example DG Score and a five-category risk breakdown.

Full stack case study

Property platform

Public website, private CRM.

I built a searchable property website for a real estate agency and a backend CRM to support the team’s daily work.

  • Next.js
  • TypeScript
  • Supabase
For buyers and renters
Filter properties, browse the map and open listings with photos and details.
For the agency team
Manage listings, seller leads and appointments in a staff workspace.
Read the case study

The brief

Give people a simple way to find properties and bring the agency’s day-to-day work into one place.

My role

I built the public search and listing pages, the CRM workflows and the backend that supports both, including the database, file storage and staff access controls.

Where I drew the line

The public website shows publishable listing information. Staff need an approved account to enter the CRM, and PostgreSQL row-level security controls which records each role can access.

Tech stack

Next.js App Router, React, TypeScript
Public pages, CRM screens and server-side handlers.
Supabase, PostgreSQL
Relational data, staff sign-in, row-level permissions and listing media storage.
Tailwind CSS, Leaflet
Responsive interfaces and interactive property maps.
Vercel
Application hosting and deployment.

The lab.

Three concept builds. Each takes a problem that separates a demo from a product and solves it in a way you can poke at. They are self-initiated studies, not client work, and the logic you’re testing runs in this page.

Concept build

Converge

Offline-first sync that never loses an edit.

Two people edit the same board. One loses signal on the Tube. When they reconnect, nobody’s work should be lost and both screens should agree.

Try it: take a device offline, change the same task on both, then reconnect.

This demo needs JavaScript to run.

What it shows
  • Every field is a last-writer-wins register stamped with a logical clock, so merges give the same answer in any order.
  • Edits apply locally first and queue while offline. The interface never waits for the network.
  • Ties break on device name, so two replicas can’t disagree about who won.

The trade-off: last writer wins is predictable, but it discards the older edit. For long text I’d reach for a sequence CRDT instead.

  • TypeScript
  • IndexedDB
  • WebSockets
  • PostgreSQL

Concept build

Once

Payment events handled exactly once.

Payment providers deliver webhooks late, twice and out of order. The customer should still be charged once, and the order should end in the right state.

Try it: deliver the same event twice, or deliver the refund before the payment.

This demo needs JavaScript to run.

What it shows
  • Each event ID is recorded when it is applied, so a redelivery is acknowledged and ignored.
  • The order is a state machine. An event that doesn’t fit the current state is parked and retried, never dropped or forced.
  • The ledger changes in the same step as the state, so the two can’t drift apart.

The trade-off: parking events needs a timeout and an alert, or a missing payment event hides a refund forever.

  • Node.js
  • PostgreSQL
  • Signed webhooks
  • Vitest

Concept build

Scope

Access rules the database enforces.

Hiding a button isn’t security. If an agent shouldn’t see a colleague’s draft listing, the database should refuse to return it.

Try it: switch role and watch which rows come back, then try to edit one you don’t own.

This demo needs JavaScript to run.

What it shows
  • Access rules live in the database as policies, so every query path gets the same answer.
  • The interface reads the same rules to decide what to show, but it is never the thing enforcing them.
  • Each role is tested for what it must not see, as well as what it can.

Where it’s real: the same approach guards the staff CRM in the property platform above.

  • PostgreSQL row-level security
  • Supabase
  • Next.js
  • TypeScript

One request, the whole stack.

Follow a single request from a click to the database and back. Every layer it passes through is one I build and look after.

  1. Interface

    Where the click happens.

    A request starts with someone pressing something. I build that surface in React and Next.js with TypeScript, and I treat keyboard access and small screens as part of the feature, not a follow-up.

    • React
    • Next.js
    • TypeScript
    • HTML5
    • CSS3
    • jQuery
    How I’d attack it
    A hidden button and a disabled field are suggestions. The browser belongs to whoever is using it, so no rule can live only here.
    In practice
    the search, map and listing pages of the property platform.
  2. API

    Where the rules live.

    The server decides what is allowed. That means validation, permissions, background jobs and the integrations that connect one system to the next.

    • Node.js
    • Python
    • REST
    • Webhooks
    • Background jobs
    How I’d attack it
    Every request replayed, reordered, malformed, and sent by an account that shouldn’t have it.
    In practice
    the server-side handlers behind the property platform’s CRM, and the event handling in Once.
  3. Data

    Where the truth lives.

    Most bugs that matter are data bugs. I model the data first, write migrations with a way back, and put access rules in the database where the interface can’t skip them.

    • PostgreSQL
    • Supabase
    • MongoDB
    • Oracle
    How I’d attack it
    One account reading another account’s rows, through whichever query path the interface forgot about.
    In practice
    row-level security deciding which records each staff role can read, tried out in Scope.
  4. Delivery

    Where it stays up.

    Shipping is a habit, not an event. I test the paths that matter, review every change, keep deploys repeatable and log enough to find the why when something breaks.

    • Vitest
    • Jest
    • Cypress
    • Git and CI/CD
    • Docker
    • Logs, metrics, traces
    • Burp Suite
    • Nmap
    • Wireshark
    • Nessus
    How I’d attack it
    Secrets baked into the build, stack traces in production, and whatever the logs quietly keep.
    In practice
    DealGrade, built as a team with Lewis Morris as CTO, is live.

And the part that isn’t code

Product thinking
Understand the need, shape the scope and take the whole thing live. Then keep iterating.
Technical leadership
Mentoring, code review and decisions written down, so the whole team builds better.

London raised. Systems thinker. Always building something.

I’m Drilon. LON B. on the internet.

Developer, dad and the person who hears “I’ve got an idea” and starts mentally designing the database.

I like thoughtful interfaces, plain conversations and software that makes someone’s day easier. After ten years, that’s still the job.

Open a card. There’s more to me than the job title.

OriginsLondon raised.A London upbringing.
A fairly dry sense of humour.
The backstoryClose the story

London shaped my sense of humour. It also taught me that “not bad” can be a very enthusiastic review.

Understatement included.
System design Build for change. Give each part of the system a clear job. How I design systemsClose the story

I start by mapping who does what and where the data goes. Then I draw boundaries around the parts likely to change, so the next feature is easier to build and test.

Default settingAlways building.Say “I’ve got an idea.”
Watch the database appear.
How my brain worksClose the story

Building things gives all that energy somewhere useful to go. Even the next business idea apparently “won’t take much time.”

Famous last words.
Communication Make decisions clear. Plain language for people.
Readable TypeScript for the next dev.
How I share decisionsClose the story

I explain trade-offs with examples and write down why we chose an approach. That gives the team a shared reference when requirements change or someone new picks up the code.

Off dutyWine > more coffee.Laptop closed.
Good conversation open.
Outside the codeClose the story

Away from the keyboard: family time, a good glass of wine and a conversation that has absolutely nothing to do with software. For at least five minutes.

There is life after deploy.
Always onDad mode.Permanently enabled.
No staging environment.
The other full-time roleClose the story

No rollback button, either. Plenty of daily practice with unexpected inputs — and a very good reason to close the laptop.

My most important project.

Let’s make it live.

It’s --:-- in London.

Hiring a senior developer

Send the role and a little about the team. I’ll come back with relevant work and my availability.

Starting a project

Describe it in your own words, or use the brief builder to turn a rough idea into a first outline you can send.

How a project runs

  1. Talk it out. The idea, the people, the problem. We ask the right questions first.
  2. Make it real. Design, build, break, improve. You see progress at every step.
  3. Let it loose. Test the details, ship with care and stay for what comes next.

Give the idea a shape

Pick what matters and leave with a useful first brief. No account needed.

What are we building?
What should it do?
A little context

Built in your browser. Nothing is submitted from this form.

Write an enquiry

Fill this in and I’ll hand it to your email app, addressed and ready to send. This page doesn’t send or store anything. Want more structure? Use the .