Forem: Shota Sabashvili

Building Digital Products in Georgia: Our Story at Wevosoft

Shota Sabashvili — Tue, 31 Mar 2026 11:43:15 +0000

When people think of tech hubs, they usually think of San Francisco, Berlin, or London. Tbilisi, Georgia rarely comes up. But over the past five years, something quiet has been happening here — and we've been part of it.

I'm Shota Sabashvili, co-founder and CTO of Wevosoft, a web development and digital agency based in Tbilisi. This is our story.

How It Started (2020)

We founded Wevosoft in 2020 — right as the world was going into lockdown. Not the best timing on paper, but in hindsight, it forced us to work lean, move fast, and focus entirely on delivering real value to clients.

The idea was simple: build a team that could handle the full digital lifecycle — from design and development to marketing and infrastructure. Not a factory. A small, focused team that actually cares about outcomes.

What We Build

Today, Wevosoft specializes in:

Web & mobile applications — custom builds using Next.js, React, and TypeScript
UI/UX design — from wireframes to production-ready interfaces
AI integration — adding intelligent features to existing products
Cloud infrastructure — AWS and GCP deployments
Digital marketing — SEO, social media, paid ads

Our stack has stayed consistent since day one: Next.js + TypeScript + Node.js + Payload CMS. We picked these tools because they scale — from a landing page to a full SaaS product.

50+ Projects Later

By 2025, we had shipped over 50 projects for 30+ clients. Some highlights:

E-commerce platforms handling thousands of daily transactions
Custom CRM systems for Georgian enterprises
AI-powered tools for content and automation
Complete rebrands with full digital presence buildouts

Each project taught us something. The biggest lesson: clients don't buy technology, they buy outcomes. Nobody wants a "Next.js app." They want more customers, faster workflows, or a product their users actually love.

Building in Georgia: The Reality

Georgia is genuinely a great place to build a tech company in 2025. The reasons are practical:

Low operational costs. Tbilisi is significantly cheaper than Western European cities, which means we can offer competitive pricing without sacrificing quality.

Strong talent. Georgian universities produce solid engineers, and the local dev community has grown fast over the past few years. We've found great people here.

Time zone advantage. UTC+4 puts us in a sweet spot — overlap with Europe in the morning, with the Gulf in the afternoon.

Startup-friendly environment. Georgia has one of the lowest corporate tax rates in the region and straightforward company registration.

The challenge? Visibility. Getting international clients to trust a company they've never heard of, based in a country they might not know well, is a real hurdle. It's something we're still actively working on.

Our Tech Philosophy

We don't chase trends. When everyone was hyped about a new framework, we stayed with Next.js because it keeps getting better and our team is genuinely fast with it.

A few principles we stick to:

Ship working software, not perfect software. Perfect is the enemy of shipped. We iterate fast, gather feedback, and improve.

TypeScript everywhere. After moving all our projects to TypeScript, our bug rate dropped noticeably. The initial investment in type definitions pays off quickly.

CMS matters. We standardized on Payload CMS after trying several others. It's developer-friendly, TypeScript-native, and powerful enough for complex content models.

Performance is a feature. We treat Core Web Vitals as a product requirement, not an afterthought.

What's Next

In 2026, we're doubling down on AI integration work — helping Georgian and international businesses add intelligent features to their products without replacing what already works.

We're also investing in our own products, not just client work. Building something of our own has always been part of the plan.

If you're building something and want to work with a team that's been in the trenches — or if you're just curious about the Georgian tech scene — reach out.

📧 info@wevosoft.com
🌐 wevosoft.ge
📍 Tbilisi, Georgia

We're small, we move fast, and we actually answer emails.

HOW MUCH DOES IT COST TO BUILD A WEBSITE IN GEORGIA IN 2026?

Shota Sabashvili — Fri, 27 Mar 2026 07:45:02 +0000

One-of the most common questions, that clients ask us, is - „How much does Website website cost?“ The answer is often is - „"It depends on the complexity."“. However this does not mean, that specific price ranges giving is impossible.

In this article in detail we will discuss, How much determines Website website price 2026 year, How much type websites exist and approximately How much can be each one Price Georgia's market.

How much determines Website website price?

Site Type and Complexity
A single-page landing and 50--page online store at the same and price cannot be built. The more more functionality there is - the more functionality time is needed for development.
Design
Template-based Design much cheaper, than from scratch created unique UI/UX Design. unique Design business from competitors distinguishes and more higher conversion ensures.
Technology
WordPress-on built site typically more cheaper, than Next.js-on created. However technology choice impacts speed, security and long-term costs.

You can read our article about this Next.js vs Wordpess

CMS (Content Management System)
CMS allows you to edit Site content. Its integration increases development time, However long-term perspective money saves.
SEO Optimization
Basic SEO (meta tags, sitemap) is often project's price is included, while full SEO Optimization is often separate service.
Integrations
online payment, CRM integration, chatbot or booking system - each additional feature increases project's cost.

Website website Types and Prices 2026 year
Landing Page (Landing Page)
A single-page site specific product or service to present.

Price in Georgia: 700 - 3,000 GEL

Timeline: 1–2 weeks

Business Website Page (Corporate Website)
5–15 -page site for business.

Price in Georgia: 2,500 - 8,000 GEL

Timeline: 3–6 weeks

online store (E‑commerce)
Product catalog, cart, online payments and order management.

Price in Georgia: 5,000 - 20,000+ GEL

Timeline: 6–12 weeks

Website Application (Web Application)
Custom platform with specific features.

Price in Georgia: 10,000 - 50,000+ GEL

Timeline: 2–6 months

What to Pay Attention Besides the Price
Long-Term Costs
Website website building Beyond exist additional costs: hosting, domain and technical support.

Speed and Performance
If site slowly loads, users is often often leave it. Google-the data, users large proportion abandons the site, If the 3 seconds longer than loads.

SEO - Findable If Google-
Many beautiful Website Page exist, that no one can find Google-. SEO Optimization Site site's success One-of the the main factors.

Mobile Version
in Georgia internet traffic large proportion Mobile devices comes from, therefore mobile-friendly Custom Design is essential.

Summary

2026 year Website website Price in Georgia approximately 700 GEL to 50,000+ GEL ranges. The key is to find a team, that understands your Business business goals and building Website a website, that real results delivers.

In this all of this Wevosoft the a team will help you. We can build any complexity website, from Landing landing page to complex functional sites. Book a Meeting, to find out which is is your priority or or contact us directly here.

7 Next.js Performance Optimizations That Took Our Site from 55 to 94 on PageSpeed

Shota Sabashvili — Tue, 17 Mar 2026 19:43:09 +0000

Last month, our agency website scored 55 on Google PageSpeed Insights (mobile). Today, it scores 94 on desktop and 78 on mobile — and we're still pushing higher.

Here are the 7 changes that made the biggest difference, with actual code you can copy into your Next.js project today.

1. Lazy Load Third-Party Scripts (GTM, Analytics, Chat Widgets)

This single change gave us the biggest performance jump. Google Tag Manager alone was loading 250KB of JavaScript on page load — most of it unused.

Before: GTM loads immediately, blocking the main thread.

// layout.tsx — DON'T do this
import { GoogleTagManager, GoogleAnalytics } from '@next/third-parties/google'

export default function Layout({ children }) {
  return (
    <html>
      <GoogleTagManager gtmId="GTM-XXXXX" />
      <body>{children}</body>
      <GoogleAnalytics gaId="G-XXXXX" />
    </html>
  )
}

After: GTM loads 3 seconds after page load or on first user interaction — whichever comes first.

// components/Analytics.tsx
'use client'
import { useEffect, useState } from 'react'
import { GoogleTagManager, GoogleAnalytics } from '@next/third-parties/google'

export default function Analytics() {
  const [load, setLoad] = useState(false)

  useEffect(() => {
    const timer = setTimeout(() => setLoad(true), 3000)
    const onInteract = () => setLoad(true)

    window.addEventListener('scroll', onInteract, { once: true })
    window.addEventListener('click', onInteract, { once: true })

    return () => {
      clearTimeout(timer)
      window.removeEventListener('scroll', onInteract)
      window.removeEventListener('click', onInteract)
    }
  }, [])

  if (!load) return null

  return (
    <>
      <GoogleTagManager gtmId={process.env.NEXT_PUBLIC_GTM_ID!} />
      <GoogleAnalytics gaId={process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID!} />
    </>
  )
}

Impact: Reduced unused JavaScript by ~130KB. LCP improved by 800ms.

We did the same for our Tawk.to chat widget — deferring it by 5 seconds. Users don't need live chat in the first 5 seconds anyway.

2. Fix the Hidden LCP Killer: CSS Animations

Our hero section had a text reveal animation — each word faded in with a blur effect. Looked great. But Google's Lighthouse saw this:

// The LCP element starts invisible!
<span style={{ opacity: 0.08, filter: 'blur(4px)' }}>
  Our hero text here
</span>

Lighthouse measures LCP at the point when the largest content becomes visible. An element with opacity: 0.08 is essentially invisible — so our LCP was 5.6 seconds (waiting for the animation to complete).

Fix: Make the LCP element visible immediately. Animate everything else.

// Hero description (LCP element) — NO animation
<p className="hero-description">
  We build modern, fast websites...
</p>

// H1, buttons, decorative elements — animate freely
<motion.h1 initial={{ opacity: 0 }} animate={{ opacity: 1 }}>
  Modern Web Development
</motion.h1>

Impact: LCP dropped from 5.6s to 1.3s on desktop.

3. Dynamic Imports for Below-the-Fold Content

Everything the user can't see on first load doesn't need to be in the initial bundle.

import dynamic from 'next/dynamic'

// These sections are below the fold — lazy load them
const ProjectsSection = dynamic(() => import('@/components/ProjectsSection'))
const FAQSection = dynamic(() => import('@/components/FAQSection'))
const TestimonialsSection = dynamic(() => import('@/components/TestimonialsSection'))
const TechStackSection = dynamic(() => import('@/components/TechStackSection'))

// CustomCursor only makes sense on desktop
const CustomCursor = dynamic(() => import('@/components/CustomCursor'), {
  ssr: false,
  loading: () => null
})

Impact: Initial JS bundle reduced by ~45KB.

4. Image Cache TTL: From 60 Seconds to 30 Days

This was an embarrassing oversight. Next.js defaults minimumCacheTTL to 60 seconds for optimized images. Every minute, returning visitors were re-downloading the same images.

// next.config.mjs
const nextConfig = {
  images: {
    minimumCacheTTL: 2592000, // 30 days
    formats: ['image/webp', 'image/avif'],
  },
}

Also added proper cache headers for all static assets:

async headers() {
  return [
    {
      source: '/:all*(svg|jpg|jpeg|png|gif|ico|webp|woff|woff2)',
      headers: [
        { key: 'Cache-Control', value: 'public, max-age=31536000, immutable' }
      ],
    },
    {
      source: '/_next/static/:path*',
      headers: [
        { key: 'Cache-Control', value: 'public, max-age=31536000, immutable' }
      ],
    },
  ]
}

Impact: Repeat visit load time dropped dramatically. PageSpeed "Serve static assets with efficient cache policy" warning disappeared.

5. Preconnect to External Domains

The browser spends time establishing connections to external domains (DNS lookup + TCP handshake + TLS). Tell it to start early:

// layout.tsx — in the <head>
<link rel="preconnect" href="https://fonts.googleapis.com" />
<link rel="preconnect" href="https://fonts.gstatic.com" crossOrigin="anonymous" />
<link rel="dns-prefetch" href="https://www.googletagmanager.com" />

Impact: FCP improved by ~100ms. Small but free.

6. ISR + On-Demand Revalidation Instead of SSR

We moved from force-dynamic (SSR every request) to ISR with on-demand revalidation. Pages are pre-rendered and served from cache. When content changes in the CMS, a webhook triggers revalidation of only the affected pages.

// Any page.tsx
export const revalidate = 3600 // Serve from cache, refresh hourly

// api/revalidate/route.ts — called by CMS webhook
import { revalidatePath } from 'next/cache'

export async function POST(request: NextRequest) {
  const { collection, slug } = await request.json()

  if (collection === 'blogs' && slug) {
    revalidatePath(`/blogs/${slug}`)
    revalidatePath('/blogs')
  }

  revalidatePath('/')
  return NextResponse.json({ revalidated: true })
}

Impact: TTFB dropped from ~400ms (SSR) to ~50ms (cached). Pages feel instant.

7. Target Modern Browsers Only

By default, Next.js transpiles code for older browsers, adding polyfills you probably don't need. Array.prototype.flat, Object.fromEntries, String.prototype.trimEnd — all natively supported in every browser your users actually use.

// package.json
{
  "browserslist": [
    "last 2 Chrome versions",
    "last 2 Firefox versions",
    "last 2 Safari versions",
    "last 2 Edge versions"
  ]
}

Impact: Saved ~12KB of polyfill code.

The Results

Metric	Before	After
Performance (Desktop)	55	94
Performance (Mobile)	45	78
LCP (Desktop)	4.4s	1.3s
LCP (Mobile)	5.6s	2.8s
Total Blocking Time	180ms	20ms
CLS	0.12	0
SEO	91	100

What's Next

We're still working on getting mobile Performance above 90. The main remaining bottleneck is third-party scripts (GTM alone accounts for ~126KB of unused JavaScript). If you find a way to make GTM lighter, let me know in the comments.

We're [Wevosoft], a web development agency in Tbilisi, Georgia specializing in Next.js, React, and modern web applications. Check out our [projects] or [book a free consultation].

How We Built a Football league Platform with Next.js and Payload CMS

Shota Sabashvili — Tue, 17 Mar 2026 19:38:47 +0000

Every developer knows the feeling — a client walks in with what sounds like a simple request: "We need a website for school sports leagues." But as you dig deeper, you realize it's anything but simple. Registration systems, tournament brackets, live standings, multi-sport support, and a CMS that non-technical staff can actually use.

This is the story of how we built Schooleague — a digital platform for school sports competitions in Georgia — using Next.js 14, TypeScript, Node.js, PostgreSQL, and Payload CMS.

The Challenge

Our client needed a platform where:

Schools could register for tournaments across multiple sports
Administrators could manage brackets, schedules, and results
Students and parents could track standings in real-time
Content editors could update news and announcements without developer help

The previous solution was a combination of spreadsheets and social media posts. Not exactly scalable.

Why We Chose This Stack

Next.js 14 (App Router)

We went with Next.js for several reasons:

Server Components reduced our client-side JavaScript by roughly 40%
ISR (Incremental Static Regeneration) let us serve tournament pages as static HTML while keeping data fresh
Built-in image optimization was critical — tournament photos and team logos needed to load fast on school Wi-Fi networks
SEO out of the box — schools needed to find their tournaments through Google

Payload CMS

We evaluated several headless CMS options (Strapi, Sanity, Contentful) and landed on Payload CMS because:

It runs on our own server — no per-seat pricing surprises
TypeScript-first, which matched our entire stack
The admin panel is clean enough for non-technical staff
Custom fields and hooks let us build complex tournament logic directly in the CMS

PostgreSQL

Tournament data is inherently relational — teams belong to schools, schools register for tournaments, tournaments have rounds, rounds have matches. PostgreSQL was the natural choice.

Architecture Overview

┌─────────────────┐     ┌──────────────────┐
│   Next.js App    │────▶│   Payload CMS    │
│  (App Router)    │     │  (API + Admin)   │
└─────────────────┘     └──────────────────┘
         │                        │
         ▼                        ▼
┌─────────────────┐     ┌──────────────────┐
│   Static Pages   │     │   PostgreSQL     │
│   (ISR Cache)    │     │   (Tournament    │
│                  │     │    Data)         │
└─────────────────┘     └──────────────────┘

Key Implementation Details

1. Tournament Bracket System

The trickiest part was generating and displaying tournament brackets dynamically. We built a recursive component that renders single-elimination, double-elimination, and round-robin formats:

type Match = {
  id: string
  round: number
  position: number
  teamA: Team | null
  teamB: Team | null
  scoreA?: number
  scoreB?: number
  winner?: Team
  nextMatchId?: string
}

function generateBracket(teams: Team[], format: TournamentFormat): Match[] {
  // Seed teams based on ranking
  const seeded = seedTeams(teams)

  // Generate match tree
  const rounds = Math.ceil(Math.log2(seeded.length))
  const matches: Match[] = []

  for (let round = 1; round <= rounds; round++) {
    const matchesInRound = Math.pow(2, rounds - round)
    for (let pos = 0; pos < matchesInRound; pos++) {
      matches.push({
        id: `r${round}-m${pos}`,
        round,
        position: pos,
        teamA: round === 1 ? seeded[pos * 2] : null,
        teamB: round === 1 ? seeded[pos * 2 + 1] : null,
        nextMatchId: round < rounds ? `r${round + 1}-m${Math.floor(pos / 2)}` : undefined
      })
    }
  }

  return matches
}

2. Real-Time Standings with ISR

Instead of WebSockets (which would have been overkill), we used ISR with a short revalidation window:

// app/tournaments/[id]/standings/page.tsx
export const revalidate = 30 // Revalidate every 30 seconds

async function StandingsPage({ params }: { params: { id: string } }) {
  const standings = await getStandings(params.id)

  return (
    <StandingsTable 
      data={standings} 
      lastUpdated={new Date().toISOString()} 
    />
  )
}

For admin score updates, we trigger on-demand revalidation through Payload hooks:

// Payload afterChange hook
const revalidateStandings: AfterChangeHook = async ({ doc }) => {
  await fetch(`${SITE_URL}/api/revalidate`, {
    method: 'POST',
    headers: { 'x-secret': REVALIDATION_SECRET },
    body: JSON.stringify({ 
      path: `/tournaments/${doc.tournamentId}/standings` 
    })
  })
}

3. Multi-Language Support

Georgian schools needed the platform in Georgian (obviously), but international schools wanted English. We used next-intl with a clean URL structure:

schooleague.ge/ — Georgian (default)
schooleague.ge/en/ — English

4. Performance Results

After launch, here's what we measured:

Metric	Score
Lighthouse Performance (Mobile)	92
Lighthouse SEO	100
First Contentful Paint	0.8s
Largest Contentful Paint	1.2s
Time to Interactive	1.5s

The key optimizations that got us there:

Server Components for everything that doesn't need interactivity
Dynamic imports for heavy components (bracket visualizer, charts)
Proper image sizing with next/image and WebP
Font optimization with next/font

Lessons Learned

1. ISR > SSR for sports data. Real-time isn't always necessary. A 30-second delay in standings is perfectly acceptable, and ISR is dramatically simpler than WebSocket infrastructure.

2. Payload CMS hooks are powerful. We handled score validation, automatic bracket advancement, and cache revalidation all through Payload hooks — no separate microservice needed.

3. Start with mobile. 80% of our users check standings on their phones during games. Mobile-first wasn't just a best practice — it was the actual use case.

4. TypeScript end-to-end pays off. Having types from the database schema through the API to the React components caught bugs before they reached production. The initial setup time was worth it.

Results

Within the first 3 months of launch:

50+ schools registered on the platform
200+ tournaments created
15,000+ page views per month during peak season
Admin time for tournament management dropped from hours to minutes

We're Wevosoft, a web development agency based in Tbilisi, Georgia. We build modern web applications with Next.js, React, and Node.js. If you're looking for a development partner, let's talk.