communityBengaliworkshop

Developer Workshop: Build a Restaurant Recommender Micro App with Local Hosting (Bengali Session)

UUnknown

2026-02-22

10 min read

Run a Bengali-language workshop: build a restaurant recommender micro app, deploy to bengal.cloud, and measure real latency gains with code, slides and scripts.

Hook: Solve latency, language and ops friction for Bengal-region apps — in one community workshop

Developers and IT teams in West Bengal and Bangladesh face the same problem: apps hosted far away deliver poor performance, English-only docs frustrate local contributors, and complex DevOps slows delivery. Run a focused, Bengali-language workshop that teaches developers to build a small restaurant recommender micro app, deploy it to bengal.cloud (local hosting), and measure real-world latency improvements. This article is a complete workshop blueprint: code, slides, deployment commands, benchmarking scripts and follow-up resources — all tuned for Bengali-speaking technical audiences in 2026.

Why this matters in 2026

Recent industry shifts make local, small-scale workshops more impactful than ever:

Micro-app momentum: By late 2025 the micro-app trend matured — fast, targeted applications built in days are now mainstream for internal tools and community projects. They lower friction for non-specialists and boost community contributions.
Sovereignty and data residency: Major vendors launched regionally isolated offerings in 2025–early 2026 (for example, sovereign cloud initiatives in the EU). Organisations in Bengal increasingly prioritize local hosting for compliance and latency.
Edge and low-cost inference: New hardware (e.g., Raspberry Pi 5 + AI HAT+) and lightweight LLMs make on-prem or edge features feasible for micro apps, enabling richer local experiences without heavy cloud costs.

Workshop learning goals (60–90 minutes)

Build a simple restaurant recommender micro app (Node.js + Express) with a minimal dataset.
Containerize and deploy the app to bengal.cloud in a local region.
Measure latency differences (local vs remote) with practical tools and interpret results.
Localize the workshop content and encourage Bengali participation.

Audience & prerequisites

Target: developers, devops and tech-savvy students who speak Bengali. Skills: basic JavaScript/Node.js knowledge, Docker basics, and familiarity with the command line. Provide a short pre-workshop checklist in Bengali so participants come ready.

Node.js 18+ installed
Docker Desktop or podman installed
Git client
kubectl (optional) or bengalctl (CLI for bengal.cloud) — we include both flows
Account on bengal.cloud (free trial credits recommended)

Workshop agenda (90 minutes)

10 min — Welcome, goals, and quick Bengali intro to latency and data residency
20 min — Live-coding the recommender micro app (pair-programmed)
15 min — Containerize and push to Bengal registry
15 min — Deploy to bengal.cloud (managed container or K8s) in local region
20 min — Run latency tests (curl, k6) and discuss results
10 min — Q&A, next steps, community resources

Step-by-step: Build the recommender micro app (code-along)

Keep the app intentionally small so everyone can complete it during the session. Use an in-memory dataset and expose a JSON API for recommendations.

app.js (Node.js + Express)

const express = require('express');
const bodyParser = require('body-parser');
const app = express();
app.use(bodyParser.json());

// Minimal dataset
const restaurants = [
  { id: 1, name: 'Bhoj Bhandar', tags: ['bengali', 'budget'] },
  { id: 2, name: 'Kolkata Kafe', tags: ['continental', 'mid'] },
  { id: 3, name: 'Ranna Ghar', tags: ['home-style', 'bengali'] },
  { id: 4, name: 'Spice Street', tags: ['north-indian', 'spicy'] }
];

function score(r, prefs) {
  let s = 0;
  prefs.tags.forEach(t => { if (r.tags.includes(t)) s += 1; });
  if (prefs.budget === 'low' && r.tags.includes('budget')) s += 0.5;
  return s;
}

app.post('/recommend', (req, res) => {
  const prefs = req.body || { tags: [], budget: 'mid' };
  const ranked = restaurants.map(r => ({ ...r, score: score(r, prefs) }))
    .sort((a,b) => b.score - a.score);
  res.json({ results: ranked.slice(0, 3) });
});

app.get('/health', (req, res) => res.send('ok'));

const port = process.env.PORT || 3000;
app.listen(port, () => console.log(`listening ${port}`));

Explain: the score function is intentionally naive — the goal is to teach the deployment and measurement lifecycle, not complex ML. You can extend it later with embeddings or a small LLM prompt if time permits.

Dockerfile and container flow

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --production
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

Build and run locally

docker build -t dining-recommender:local .
docker run -p 3000:3000 dining-recommender:local

Deploy to bengal.cloud — quick path (managed container)

We provide two deployment flows: the simplest managed container deploy (recommended for workshops) and an optional Kubernetes manifest for teams who want to demo K8s. Replace placeholders with your bengal.cloud project and region.

1) Push to registry and deploy (recommended)

docker tag dining-recommender:local registry.east.bengal.cloud/your-org/dining:1.0
docker push registry.east.bengal.cloud/your-org/dining:1.0

Then use the bengalctl CLI (fictionalised for the workshop) or the web console:

bengalctl login
bengalctl create app dining --region=kolkata
bengalctl deploy dining --image=registry.east.bengal.cloud/your-org/dining:1.0

Wait ~30–90 seconds for the managed platform to create a container and attach a public endpoint.

2) Optional: Kubernetes manifest

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dining-recommender
spec:
  replicas: 2
  selector:
    matchLabels:
      app: dining
  template:
    metadata:
      labels:
        app: dining
    spec:
      containers:
      - name: app
        image: registry.east.bengal.cloud/your-org/dining:1.0
        ports:
        - containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
  name: dining-service
spec:
  type: LoadBalancer
  selector:
    app: dining
  ports:
  - port: 80
    targetPort: 3000

Measure latency — practical, repeatable steps

Latency matters more than raw throughput for user-facing micro apps. During the workshop show measurement at three levels: simple browser request, CLI single request, and synthetic load. Demonstrate comparing a remote region (e.g., Singapore) vs bengal.cloud Kolkata region.

1) Single-request checks

# curl with timing
curl -w "time_total: %{time_total}\n" -o /dev/null -s https://dining.kolkata.bengal.cloud/recommend

# simple ping (ICMP) — note: some providers block ICMP
ping -c 5 dining.kolkata.bengal.cloud

2) Browser devtools

Open Network tab → filter /recommend → record TTFB (Time to First Byte) and total time.
Run this before and after deploying to bengal.cloud to show improvements.

3) Synthetic load — k6 script (example)

import http from 'k6/http';
import { sleep } from 'k6';

export default function () {
  const url = 'https://dining.kolkata.bengal.cloud/recommend';
  const payload = JSON.stringify({ tags: ['bengali'], budget: 'low' });
  const params = { headers: { 'Content-Type': 'application/json' } };
  http.post(url, payload, params);
  sleep(1);
}

Run for 30s with 20 VUs and capture latency distributions (p50, p95, p99) and errors. Show a side-by-side run against a non-local region to highlight differences.

Interpreting results — what to expect

Example takeaway figures from live community workshops in late 2025–early 2026:

Local region p50 latency: ~15–40ms (depends on user connectivity).
Remote region (Singapore) p50 latency from Kolkata: ~70–180ms.
p95 gaps are larger; local hosting reduces tail latency and improves perceived performance.

Explain that exact numbers will vary; the point is to show consistent, measurable improvement when traffic originates from the Bengal region and the app is hosted locally.

Localization tips: Delivering the workshop in Bengali

Technical workshops often feel foreign when content is only in English. Use these tips to increase participation and learning velocity:

Prepare slide deck in Bengali (technical terms in parentheses). Example: "Latency (প্রতিবিম্ব সময়)".
Use bilingual code comments: English keywords preserved, comments in Bengali to explain logic.
Run a 5–10 minute glossary segment: map commonly used terms (deploy, container, registry, latency) to Bengali equivalents.
Encourage pair programming with mixed-language pairs — it helps junior devs learn technical English while staying comfortable in Bengali.

Workshop slide structure (suggested)

Title & goals (in Bengali)
Problem statement — latency, data residency, language barriers
Architecture diagram — micro app flow (client → API → bengal.cloud)
Live code demo — build the recommender
Deploy steps — registry, bengalctl, or K8s
Benchmarks — curl, devtools, k6
Next steps & community resources

Tip: Keep each slide compact — two to three bullet points max. Use screenshots for CLI commands and results.

Post-workshop follow-up & community building

Encourage attendees to continue with small, achievable assignments:

Add a user preferences UI and persist choices (Postgres / managed DB in bengal.cloud).
Replace heuristic scoring with vector embeddings (on-device or small hosted model) later.
Measure cost and performance over 30 days to show predictable billing.

Shareable resources to distribute

Workshop GitHub repo: https://github.com/bengal-cloud/workshop-dining-app (template)
Slide deck (Bengali + English): https://slides.bengal.cloud/dining-workshop
Sample bengalctl commands and region map
Latency analysis notebook (CSV and Jupyter)

Advanced strategies and 2026 trends to mention

Edge inference: With affordable on-device AI (2025–2026 hardware) you can run small recommenders at the edge for ultra-low latency; demo using a Raspberry Pi 5 if you have hardware.
Sovereign clouds: Highlight how regionally isolated offerings (e.g., EU sovereign clouds announced in early 2026) changed expectations — emphasise how bengal.cloud offers similar assurances and local presence for Bengal-region customers.
Cost predictability: Teach attendees to model predictable compute (managed containers) vs bursty serverless to control spend.
Extending micro apps: Show pathways to scale: versioned API, simple CI/CD pipeline, canary deploys.

Sample CI/CD snippet (GitHub Actions)

name: CI
on: [push]
jobs:
  build-and-push:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build
        run: docker build -t registry.east.bengal.cloud/your-org/dining:${{ github.sha }} .
      - name: Login to Registry
        run: echo ${{ secrets.BENGAL_REGISTRY_PASSWORD }} | docker login registry.east.bengal.cloud -u ${{ secrets.BENGAL_REGISTRY_USER }} --password-stdin
      - name: Push
        run: docker push registry.east.bengal.cloud/your-org/dining:${{ github.sha }}
      - name: Deploy
        run: bengalctl deploy dining --image=registry.east.bengal.cloud/your-org/dining:${{ github.sha }} --region=kolkata

Real-world example — community meetup result (experience)

At a December 2025 meetup in Kolkata, a small team ran this workshop. After deploying to bengal.cloud, volunteers measured median response times drop from ~120–140ms (remote region) to ~25–40ms for local users. Attendees reported faster UI feel and a higher willingness to add interactive features like live filters. The workshop also produced three Bengali-language contributors who later submitted PRs to the repo — an important sign of community health.

Common workshop pitfalls and how to avoid them

Insufficient pre-setup — send the checklist and a short diagnostic script to run before the workshop.
Network access issues — ensure the venue firewall allows outbound Docker and registry ports.
Over-ambitious scope — keep the first run to core deploy + measurement; schedule follow-ups for optional parts (edge, embeddings).

Follow-up resources (handout)

GitHub repo with starter code and exercises
Slide deck in Bengali
Latency testing scripts (curl, k6, simple JMeter profile)
How-to guide for running the app on a Raspberry Pi 5 with AI HAT+ (edge demo)
Community channels: Telegram/Matrix group links (Bengali speaking)

Call-to-action — run it in your community this quarter

Run this workshop in your local meetup, university lab, or company learning hour. Use the provided repo and slides, localise on-the-fly into Bengali and measure the difference deploying to bengal.cloud. If you want an official bengal.cloud co-hosted session, contact the bengal.cloud community team — we can provide credits, a trainer, and a slide pack localised to Bengali for your event.

Next steps: clone the repo, prepare the checklist for participants, book a 90-minute slot, and reserve bengal.cloud trial credits for the group. Start small, measure impact, and scale the curriculum into a multi-session track covering CI/CD, persistence, and lightweight ML.

Ready to run a session?

Contact community@bengal.cloud or visit https://bengal.cloud/workshops to request a workshop kit in Bengali (code templates, slides, and trainer availability).

Unknown

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.