Skip to content

BUILD. DEPLOY. SCALE.

We build websites, apps and AI automation, then keep them running, for clients anywhere in the world.

START A PROJECTEXPLORE OUR ENGINEERING
  1. WEBSITE — next.js · edge — online
  2. MOBILE — ios · android — online
  3. API GATEWAY — rest · jwt · rate-limited — healthy
  4. svc/auth — oidc · sessions — healthy
  5. svc/core — domain api — healthy
  6. svc/jobs — rolling 3/5 — deploying
  7. POSTGRESQL — primary + 2 rr — healthy
  8. MONGODB — rs0 · 3 members — healthy
  9. REDIS — cache · queues — healthy
  10. MINIO — object storage — healthy
  11. MONITORING — prometheus · grafana — monitoring

Technologies we build with

THE TOOLS WE BUILD WITH

  • WE BUILD THE PRODUCT
    • React — Component UI library
    • Next.js — Full-stack framework
    • Node.js — Runtime and services
    • PostgreSQL — Relational database
    • MongoDB — Document database
    • Redis — Cache and queues
    • MinIO — S3 object storage
  • WE BUILD THE SYSTEM RUNNING IT
    • Git — Version control
    • Jenkins — Build automation
    • Argo CD — GitOps delivery
    • Terraform — Infrastructure as code
    • Ansible — Configuration management
    • Docker — Containerisation
    • Kubernetes — Orchestration
    • Nginx — Reverse proxy
    • Linux — Server operating system
    • AWS — Cloud platform
    • Prometheus — Metrics and alerts
    • Grafana — Dashboards
    • GitHub — Source and pull requests
    • GitHub Actions — Hosted build pipelines
    • Cloudflare — DNS, CDN, WAF and Turnstile
    • Tailscale — Private mesh network
    • Azure — Cloud platform
    • Google Cloud — Cloud platform
    • Oracle Cloud — Cloud platform
    • Podman — Rootless containers
    • Datadog — Metrics and tracing
  1. IDEA
  2. DESIGN
  3. CODE
  4. APPLICATION
  5. API
  6. INFRASTRUCTURE
  7. DEPLOYMENT
  8. MONITORING
  9. SCALE
SCROLL ↓

Geekholic Solutions is an engineering practice based in India that works remote-first with clients worldwide. It builds websites, web and mobile apps and AI automation, and handles the DevOps and infrastructure behind them.

AI automation
01DIGITAL PRODUCTSDESIGN → CODE → APPLICATION

WE BUILD DIGITAL PRODUCTS.

From high-performance websites to complex applications, we design and build digital products that are ready for production.

PRODUCT 01WEBSITES

Websites built to perform.

Modern websites built for performance, search, every screen size, every user and measurable conversion.

Performancetarget LCP 0.9 s · CLS 0.01
SEOschema · sitemaps · target 100
Responsive design320 → 2560 px
AccessibilityWCAG 2.2 AA
Conversionanalytics · A/B tests
  • LCP target 0.9 s
  • CLS target 0.01
  • INP target 64 ms
  • Lighthouse target 100 / 100
Show architecture
  1. WEBSITEsample site
  2. EDGE / CDNcloudflare · cdn
  3. NEXT.JSssr · isr · edge
  4. API / CMSheadless · cached
  5. DATABASEpostgres · content

HOVER STATE · ARCHITECTURE REVEALED BENEATH THE PAGE

Websites
PERFORMANCETARGET
LCP
0.9 s
CLS
0.01
INP
64 ms
Lighthouse
100 / 100

PRODUCT 02WEB APPLICATIONS

Applications that do the work.

Dashboards, workflows and platforms with real authentication, APIs, background jobs and data behind every screen.

Dashboard & user managementRBAC · audit log
AuthenticationOIDC · JWT · MFA
API requeststarget p95 42 ms
Background jobsqueues · retries
Notificationsemail · push · webhook
  • NEXT.JS
  • REACT
  • NODE.JS
  • API
  • POSTGRESQL
  • REDIS
Show architecture
  1. DASHBOARDreact · next.js
  2. FRONTENDnext.js · react
  3. APIrest · graphql
  4. BACKENDnode.js
  5. DATABASEpostgres · redis
  6. AUTHoidc · jwt · mfa
  7. JOBSqueues · retries
  8. NOTIFICATIONSemail · push · webhook
Web applications
API REQUESTSAMPLE
POST
/v1/invoices
status
201 · 42 ms
auth
jwt · scope:billing
BACKGROUND JOBSAMPLE
email.send
212 ms
queue
redis · 128

PRODUCT 03MOBILE APPLICATIONS

Built for every screen.

iOS and Android apps sharing one API, one auth system and one data layer with your web product.

  • API
  • AUTHENTICATION
  • DATABASE
  • NOTIFICATIONS
  • STORAGE
  • iosOrder shippedsample · apns · 180 ms
  • androidTask syncedoffline queue flushed
Mobile applications
  • iOS — swift · apns
  • ANDROID — kotlin · fcm
  • API — shared with web
  • AUTHENTICATION — one identity
  • DATABASE — one data layer
  • NOTIFICATIONS — apns · fcm
  • STORAGE — media · offline sync

  1. DEVELOPMENT

    application · api · mobile

  2. HANDOFF

    sample: commit a9f3c1e → build #1842

  3. DEVOPS

    pipeline · infrastructure · operations

02FROM CODE TO PRODUCTIONJOURNEYCODE → DEPLOYMENT

EVERY COMMIT HAS A DESTINATION.

Every commit runs the same path: build, test, scan, package, deploy, watch. Nothing reaches production by hand. The build shown is a sample.

CODE → DEPLOYMENT
DEPLOYMENT_ID
dep-7c21e9
BUILD_ID
#1842
commit
a9f3c1e
STAGE
SECURITY · SCANNING
ELAPSED
02:14 / est 04:40

  1. 01

    CODE

    DONE

    STAGE
    app/page.tsx
    ELAPSED
    —
    a9f3c1e

  2. 02

    COMMIT

    DONE

    STAGE
    signed · GPG
    ELAPSED
    —
    +214 −38

  3. 03

    BUILD

    DONE

    STAGE
    next build
    ELAPSED
    38s
    92 KB gz

  4. 04

    TEST

    DONE

    STAGE
    vitest · playwright
    ELAPSED
    1m 12s
    412 passed · cov 84%

  5. 05

    SECURITY

    RUNNING

    STAGE
    trivy · semgrep
    ELAPSED
    02:14
    scanning

  6. 06

    CONTAINER

    QUEUED

    STAGE
    docker buildx
    ELAPSED
    46s
    sha256:4be1 · 92 MB

  7. 07

    DEPLOY

    QUEUED

    STAGE
    argo rollout
    ELAPSED
    —
    canary 20%

  8. 08

    MONITOR

    QUEUED

    STAGE
    prometheus · grafana
    ELAPSED
    —
    slo target 99.99%

SAMPLE · STAGE 05 / SECURITY

02:14
SASTsemgrep 1,204 rules0 high
SCAtrivy fs 318 deps0 critical
IMAGEtrivy imagescanning
SECRETSgitleaksclean
SBOMsyft → cosign attestqueued
03DEVOPS & INFRASTRUCTUREJOURNEYINFRASTRUCTURE

INFRASTRUCTURE THAT DOESN'T GET IN THE WAY.

Containerised services on Kubernetes, fronted by a global edge and backed by managed data. Your team ships features while the platform stays out of the way. The container image shown is a sample.

DevOps & infrastructure
  • Docker
  • Kubernetes
  • Linux
  • CI/CD
  • Nginx
  • Cloudflare
  • PostgreSQL
  • MongoDB
  • Redis
  • MinIO
  1. EDGE: cloudflare · waf · cdn — healthy
  2. INGRESS: nginx · tls 1.3 — healthy
  3. KUBERNETES: sample · 12 nodes · 84 pods — healthy
  4. SERVICES: sample · 24 · docker · linux — deploying
  5. DATABASE: postgres · mongo · redis — healthy
  6. STORAGE: minio · s3 api — healthy
04OPERATIONSJOURNEYMONITORING

WE RUN WHAT WE BUILD.

Deploys, dashboards, alerts and on-call. We keep running what we build, with on-call support available under a support agreement. Every figure below is simulated demo data.

  • SAMPLE UPTIME

    99.99%

  • P95 LATENCY

    31 ms

  • REQUESTS / MIN

    748,920

  • ERROR RATE

    0.02%

REQUEST THROUGHPUT
  1. 14:22:03[ok]web-app · GET /dashboard 200 31ms
  2. 14:22:07[ok]api · POST /v1/orders 201 42ms
  3. 14:22:12[ok]argo · rollout web-v4.18.2 step 3/5
  4. 14:22:18[ok]mobile-api · push.sent ios=412 android=388
  5. 14:22:24[warn]hpa · api scaled 6 → 8 replicas
SYSTEM_STATUSOPERATIONALregion: ap-south-1cluster: prod-01last 1hDEMO 14:22:07 UTC
  • CPU38%
  • MEMORY61%
  • NETWORK1.82GB/s
  • REQUESTS12,482/s
  • LATENCY24ms
  • UPTIME99.99%

REQUEST THROUGHPUTrps / p95 latency · all applications

14:08:40 — rps 12,482, p95 31ms ▲ deploy.

KUBERNETESprod-01 · v1.31

24
SERVICES
12
NODES
84
PODS
3
DEPLOYS
  • n0138%
  • n0244%
  • n0331%
  • n0452%
  • n0540%
  • n0636%
  • n0729%
  • n0847%
  • n0933%
  • n1041%
  • n1139%
  • n1235%

DATABASE_STATUSlag 0.2s

POSTGRESQLprimary + 2 rrHEALTHY
MONGODBrs0 · 3 membersHEALTHY
REDIShit 97.8%HEALTHY

LOG STREAMtail -f production

  1. 14:22:06web-appGET /dashboard 200 31ms
  2. 14:22:06apiPOST /v1/orders 201 42ms
  3. 14:22:05argorollout web-v4.18.2 step 3/5
  4. 14:22:05mobile-apipush.sent ios=412 android=388

MONITORINGstack

  • PROMETHEUS

    142/142 targets up

  • GRAFANA

    18 dashboards

  • APPLICATIONS

    24 services up

  • ALERTS

    0 firing

Simulated demo data

SYSTEM_STATUS OPERATIONAL · CPU 38% · MEMORY 61% · NETWORK 1.82GB/s · REQUESTS 12,482/s · LATENCY 24ms · UPTIME 99.99% · KUBERNETES 24 SERVICES, 12 NODES, 84 PODS, 3 DEPLOYS · Simulated demo data

Cloud & self-hosted
05SECURITY

SECURITY IS ARCHITECTURE.

Security is considered from architecture through deployment and operation.

  • AuthenticationOIDC · MFA
  • AuthorizationRBAC · scoped JWT
  • Secretsvault · rotation
  • Network securitymTLS · default-deny
  • Access controlleast privilege
  • BackupsPITR · 3-2-1
  • Monitoringaudit · alerts

SAMPLE: ALL CONTROLS ACTIVE

  1. IDENTITY
  2. API
  3. APPLICATION
  4. CONTAINER
  5. DATABASE
  6. INFRASTRUCTURE
  1. YOUR PRODUCT
  2. IDENTITY: OIDC · MFA · RBAC
  3. API: mTLS · rate-limited
  4. APPLICATION: input validation · CSP
  5. CONTAINER: non-root · read-only fs
  6. DATABASE: encrypted · PITR
  7. INFRASTRUCTURE: hardened hosts · backups
Security & reliability
06ARCHITECTURE

WE DON'T JUST SHOW THE PRODUCT. WE SHOW HOW IT WORKS.

Three systems we build, drawn the way we draw them for ourselves. Figures in the drawings are sample targets.

  • MODERN WEBSITE

    5 hops
    Next.js / ssr / isrhealthy
    render
    ISR 60s
    LCP
    0.9 s
    bundle
    92 KB gz
    images
    avif · responsive

    MODERN WEBSITE — components and connections, in request order

    1. User, browser · mobile, healthy. entry: organic · direct · paid. devices: 320 → 2560 px. Connects to Cloudflare.
    2. Cloudflare, cdn · waf · dns, healthy. PoPs: 312. cache: stale-while-revalidate. waf: managed + custom rules. Connects to Next.js.
    3. Next.js, ssr / isr, healthy. render: ISR 60s. LCP: 0.9 s. bundle: 92 KB gz. images: avif · responsive. Connects to API.
    4. API, route handlers, healthy. runtime: node 22. cache: tag-based revalidate. Connects to Database.
    5. Database, postgresql, healthy. content: headless CMS. backups: PITR · nightly.

  • WEB APPLICATION

    7 hops
    Backend / node.js workersdeploying
    runtime
    node 22 ×4
    jobs/min
    1,840
    retries
    0.3%
    auth
    service token

    WEB APPLICATION — components and connections, in request order

    1. User, web · ios · android, healthy. clients: 3 surfaces, one API. session: refresh-token rotation. Connects to Frontend.
    2. Frontend, react · next.js, healthy. state: server components + zustand. INP: 64 ms. Connects to API.
    3. API, rest · jwt, healthy. p95: 42 ms. authz: scoped JWT · RBAC. limits: 600 req/min per key. Connects to Backend.
    4. Backend, node.js workers, deploying. runtime: node 22 ×4. jobs/min: 1,840. retries: 0.3%. auth: service token. Connects to Redis.
    5. Redis, cache · queues, healthy. hit rate: 97.8%. queues: email · export · webhook. Connects to PostgreSQL.
    6. PostgreSQL, primary · replicas, healthy. topology: primary + 2 read replicas. lag: 0.2 s. Connects to Object storage.
    7. Object storage, minio · s3, healthy. api: S3-compatible. access: signed URLs, 15 min.

  • PRODUCTION PLATFORM

    6 layers
    Kubernetes / prod-01 · 12 nodeshealthy
    version
    1.31
    pods
    84 running
    hpa
    api 6 → 8
    policy
    default-deny

    PRODUCTION PLATFORM — components and connections, in request order

    1. Edge, cloudflare, healthy. tls: 1.3 · HSTS preload. waf: bot + rate rules. Connects to Ingress.
    2. Ingress, nginx · tls, healthy. termination: TLS 1.3. routing: host + path. Connects to Kubernetes.
    3. Kubernetes, prod-01 · 12 nodes, healthy. version: 1.31. pods: 84 running. hpa: api 6 → 8. policy: default-deny. Connects to Services.
    4. Services, 24 deployments, deploying. images: non-root · read-only fs. rollout: canary 20% · auto rollback. Connects to Database.
    5. Database, pg · mongo · redis, healthy. backups: PITR + nightly snapshot. Connects to Monitoring.
    6. Monitoring, prometheus · grafana, monitoring. targets: sample 142/142 up. SLO target: 99.99%. alerts: sample 0 firing.
07THE TECHNOLOGY CONSTELLATION

ONE STACK. ONE CONNECTED SYSTEM.

Every tool belongs to a cluster of the system, and every line shows how two of them connect.

List view

  • DELIVERY

    How a commit becomes a release.

    • GitVersion control
    • JenkinsBuild automation
    • Argo CDGitOps delivery

  • APPLICATION

    What the user touches.

    • ReactComponent UI library
    • Next.jsFull-stack framework
    • Node.jsRuntime and services

  • AUTOMATION · IaC

    Infrastructure described, not clicked.

    • TerraformInfrastructure as code
    • AnsibleConfiguration management

  • DATA

    Where the product keeps its state.

    • PostgreSQLRelational database
    • MongoDBDocument database
    • RedisCache and queues
    • MinIOS3 object storage

  • INFRASTRUCTURE

    What the services run on.

    • DockerContainerisation
    • KubernetesOrchestration
    • NginxReverse proxy
    • LinuxServer operating system

  • CLOUD · AWS

    When the workload lives in the client’s own account.

    • AWSCloud platform
    • S3Object storage
    • LambdaServerless functions

  • OBSERVABILITY

    How we know it is working.

    • PrometheusMetrics and alerts
    • GrafanaDashboards

Connections

  • Git → Jenkins: A push to a protected branch starts the pipeline: build, test, scan.
  • Jenkins → Docker: The pipeline builds the multi-stage image and pushes it to the registry.
  • Jenkins → Argo CD: Jenkins bumps the image tag in Git; Argo CD is what notices.
  • Argo CD → Kubernetes: Argo CD is the only thing that applies manifests, so the cluster always matches Git.
  • Terraform → AWS: Every account is described in Terraform. Nothing is created in the console by hand.
  • Terraform → Kubernetes: Cluster, node pools and add-ons are Terraform modules, not click-ops.
  • Ansible → Linux: Hosts are configured and patched by Ansible, so a rebuilt box comes back identical.
  • Nginx → Next.js: Page requests reach the Next.js server behind the ingress.
  • Next.js → React: Next.js renders React on the server and hydrates only the interactive islands.
  • Next.js → Node.js: Route handlers and server actions run on the Node.js runtime.
  • React → Node.js: The client talks to one Node.js API; there is no second backend language to keep in sync.
  • Node.js → PostgreSQL: The API reads and writes relational data through a pooled connection.
  • Node.js → MongoDB: Document-shaped records that do not fit a relational schema live here.
  • Node.js → Redis: Redis holds the response cache, rate-limit counters and the job queues.
  • PostgreSQL → Redis: Hot reads are served cache-aside from Redis and invalidated on write.
  • MinIO → Kubernetes: Object storage runs in the cluster and serves uploads through signed URLs.
  • MinIO → S3: MinIO speaks the S3 API, so the same code runs self-hosted or on AWS.
  • Linux → Docker: Containers are Linux processes; hosts are hardened before anything runs on them.
  • Docker → Kubernetes: Kubernetes schedules the images Docker builds across the node pool.
  • Linux → Kubernetes: Every node in the pool is a hardened Linux host we patch on a schedule.
  • Nginx → Kubernetes: Ingress routes each host and path to the right service inside the cluster.
  • AWS → Kubernetes: When a client hosts in their own AWS account, the node pool runs there.
  • AWS → S3: Artefacts, uploads and database snapshots go to S3 rather than a node’s disk.
  • AWS → Lambda: Short, bursty work runs as a function instead of holding a container open.
  • Lambda → S3: Uploads trigger a function: resize, scan, index, write the result back.
  • Prometheus → Kubernetes: Prometheus scrapes every pod and node, and alerts on SLO burn rate.
  • Prometheus → Grafana: Grafana reads Prometheus for the dashboards on-call opens.
08PROJECTS

FROM CONCEPT TO PRODUCTION.

Our own product, and client work we have permission to show.

  • web applications
  • devops infrastructure
  • cloud self hosted
  • security reliability
PROBLEM
Servers, containers, clusters, pipelines and DNS each come with their own console, so a DevOps engineer spends the day switching between them.
ARCHITECTURE
A lightweight agent runs on each managed server and reports back to the platform.
PRODUCT
One dashboard for monitoring, containers, deployments, CI/CD, security checks, DNS and access control.
INFRASTRUCTURE
Works with standalone servers and with Docker, Podman and Kubernetes (K3s, K0s, MicroK8s).
RESULT
Already deployed for customers. Customer names stay private. A demo is available on request.

PRODUCT · DEVOPS · KUBERNETES

View project ↗
09ENGINEERING PROCESS

ONE PROCESS. FROM FIRST COMMIT TO PRODUCTION.

Every stage moves the product and the infrastructure forward together.

  1. 01. DISCOVER

    user journeys · goals · KPIs

    traffic profile · compliance · budget

    DONE

  2. 02. ARCHITECT

    information architecture · data model

    topology · failure domains · cost model

    DONE

  3. 03. DESIGN

    UI system · prototypes · usability

    environments · IaC modules

    DONE

  4. 04. BUILD

    frontend · API · mobile

    pipelines · clusters · databases

    DONE

  5. 05. SECURE

    auth · input validation · CSP

    secrets · network policy · scanning

    IN PROGRESS

  6. 06. DEPLOY

    release notes · feature flags

    canary · automated rollback

    QUEUED

  7. 07. MONITOR

    product analytics · errors

    SLOs · alerts · dashboards

    QUEUED

  8. 08. SCALE

    new features · new markets

    autoscaling · multi-region

    QUEUED

09WHO OWNS WHAT

ONE PARTNER. SEVEN DISCIPLINES.

Geekholic Solutions owns the interface, the pipeline and the machines, so nothing falls between two vendors.

DISCIPLINEWHAT IT OWNSTOOLS
DELIVERYEvery change is reviewed, built and shipped the same way, every time.Git · Jenkins · Argo CD
APPLICATIONOne language across the client and the API, rendered on the server first.React · Next.js · Node.js
AUTOMATION · IaCNothing is created by hand. A rebuilt environment comes back identical.Terraform · Ansible
DATAThe right store for each shape of data, and a cache in front of the hot path.PostgreSQL · MongoDB · Redis · MinIO
INFRASTRUCTUREHardened hosts, containers we build ourselves, and a scheduler that owns rollout.Docker · Kubernetes · Nginx · Linux
CLOUD · AWSThe same architecture, in your account, under your billing and your policies.AWS · S3 · Lambda
OBSERVABILITYWe find out from a dashboard, not from you.Prometheus · Grafana
10WHY GEEKHOLIC SOLUTIONS

PRODUCT THINKING. ENGINEERING DISCIPLINE.

We own the interface, the API and the machines it runs on, so nothing falls between two vendors.

  • 01 · PRODUCT

    Build products

    We build modern websites and applications.

    • WEB
    • APP
    • MOBILE

  • 02 · SYSTEM

    Build infrastructure

    We engineer the systems that run them.

    • CI/CD
    • KUBERNETES
    • SECURITY

  • 03 · SCALE

    Build for scale

    We design for reliability, performance and growth.

    • SLOs
    • AUTOSCALING
    • OBSERVABILITY

WEBSITE · APPLICATION · API · INFRASTRUCTURE · MONITORING

LET'S BUILD WHAT COMES NEXT.

From your first idea to production infrastructure, Geekholic Solutions engineers the complete digital system.

START A PROJECTTALK TO US