SODA Foundation and Aitra: The Open-Source Project Making AI Greener

 

What Is SODA Foundation?

SODA Foundation is an open-source project under the Linux Foundation. Its mission is simple: make data management and storage work smoothly across cloud, edge, and on-premise systems

.

Think of it as a "universal translator" for data storage. Instead of locking your data into one vendor's system, SODA helps you move and manage data freely across different platforms

.

Founded in 2020 (originally called OpenSDS), SODA now includes major players like Huawei, Fujitsu, NTT Communications, Toyota, Sony, and China Unicom

.

---

What Is Aitra?

Aitra is an open-source project by SODA Foundation that measures how much energy AI systems use.

Here's the problem Aitra solves: When you run AI models (like ChatGPT-style tools), they consume massive amounts of GPU power. But most businesses have no idea how much energy each AI task actually costs

.

Aitra fixes this by tracking "energy per output token" — basically, how many joules of electricity it takes to generate each piece of AI output

.

Aitra in Plain English

What Aitra Does	Why It Matters
Measures GPU energy in real-time	Know exactly where your AI costs come from
Attributes energy to specific workloads	Chargeback per team or project
Runs on Kubernetes	Works with modern cloud infrastructure
Open source (Apache 2.0)	Free to use and modify

---

Why Should You Care About AI Energy?

If you run any AI tools on your website or servers, energy costs are real money. Aitra helps you:

1. See the hidden costs — Most companies only track GPU usage time, not actual energy consumption

2. Optimize efficiency — Find which AI models or configurations waste the most power

3. Report carbon usage — Meet ESG (Environmental, Social, Governance) requirements

4. Reduce bills — Better scheduling = lower electricity costs

Aitra was featured at KubeCon Japan 2026, where companies like SoftBank and NTT DOCOMO showed interest in using it for their AI data centers

.

---

Aitra's Key Metric: Joules Per Token

The core measurement is called aitra_j_per_token — joules (energy) divided by output tokens (work done)

.

Lower is better. A lower number means your AI is more efficient — it produces more output for less energy.

Aitra also tracks:

• aitra_idle_time_ratio — How often GPUs sit unused

• aitra_gpu_power_watts — Real-time power draw

These metrics integrate with Kubernetes and tools like KAI Scheduler to automatically place AI workloads on the most efficient nodes

.

---

Who Should Use SODA Foundation and Aitra?

Perfect for you if:

• You run AI models on GPUs (cloud or on-premise)

• Your electricity bill for AI is growing

• You need to report carbon/energy usage

• You want to optimize costs across teams

Not needed if:

• You only use basic website hosting

• Your AI usage is minimal (under a few hours daily)

---

The Bigger Picture: Green AI Matters

As AI becomes more common, energy consumption is exploding. Data centers already use ~1-2% of global electricity, and AI is pushing that higher.

Aitra represents a shift toward accountable AI — where companies can measure and reduce their AI carbon footprint, not just chase performance.

---

Suggested Searches

Try these on Google to learn more:

• SODA Foundation Aitra energy measurement

• AI inference energy efficiency Kubernetes

• GPU power consumption monitoring open source

• green AI carbon footprint tools

Related Links:

• SODA Foundation: https://sodafoundation.io

• Aitra Project: https://aitra.ai

• GitHub (Aitra Meter): https://github.com/sodafoundation/aitra-meter

• Domains, Hosting & Website Tools: https://www.syscom.co.in

Snowflake vs YTsaurus: Which Big Data Platform Fits Your Needs?

 

Introduction

Choosing the right data platform can make or break your analytics strategy. Snowflake and YTsaurus are two powerful but very different solutions for handling large-scale data. One is a commercial cloud data warehouse, the other is an open-source distributed platform built by Yandex. Let's break down what each offers in simple terms.

---

What is Snowflake?

Snowflake is a fully managed cloud data warehouse that runs entirely on cloud infrastructure like AWS, Azure, or Google Cloud

. You don't install anything—it just works.

Key strengths:

• Zero management: Snowflake handles all hardware, software updates, and maintenance for you

Separation of storage and compute: Scale your storage and computing power independently, paying only for what you use

SQL-first approach: Built for analysts and data engineers who love SQL

Semi-structured data support: Handles JSON, XML, and nested data efficiently

Pay-as-you-go pricing: Charged by the second for compute usage

Best for: Companies wanting a turnkey analytics solution without infrastructure headaches.

---

What is YTsaurus?

YTsaurus (pronounced "wai-tee-saw-rus") is an open-source platform for distributed storage and processing of massive datasets

. It was developed by Yandex starting in 2010 and powers most of their services, including YandexGPT and search indexing

.

Key strengths:

• Extreme scalability: Handles exabytes of data across 10,000+ nodes and up to 1 million CPU cores

MapReduce + More: Supports batch processing, real-time queries, and OLTP workloads in one system

Open source (Apache 2.0): Free to use, modify, and self-host

Built-in tools: Includes CHYT (ClickHouse over YT) and SPYT (Apache Spark over YT)

No single point of failure: Designed for reliability at massive scale

Best for: Organizations with large engineering teams handling petabyte-scale data who want full control.

---

Head-to-Head Comparison

Feature	Snowflake	YTsaurus
Type	Cloud data warehouse	Distributed storage & processing platform
Deployment	Cloud only (vendor-managed)	Self-hosted or managed cloud
License	Commercial/proprietary	Open source (Apache 2.0)
Query Language	Standard SQL	YQL (SQL-like dialect)
Pricing	Pay-per-second compute + storage	Infrastructure costs only (open source)
Best Scale	Terabytes to low petabytes	Exabytes and beyond
Learning Curve	Low (SQL familiar to most)	Moderate to high (requires engineering expertise)

---

When to Choose Snowflake

Pick Snowflake if you:

• Want a plug-and-play solution with zero infrastructure management

• Need fast time-to-value for business intelligence and analytics

• Prefer predictable, usage-based pricing

• Have a team that primarily knows SQL

When to Choose YTsaurus

Pick YTsaurus if you:

• Have petabyte or exabyte-scale data requirements

• Want full control over your infrastructure

• Have strong engineering resources to manage a distributed system

• Need MapReduce and custom computation capabilities

• Want to avoid vendor lock-in with an open-source solution

---

Suggested Search & Related Links

Want to explore more? Try searching these terms on Google:

• "Snowflake data warehouse pricing"

• "YTsaurus tutorial getting started"

• "MapReduce vs SQL analytics"

For reliable domain registration and web hosting to launch your data project's online presence, check out Syscom at https://www.syscom.co.in. They offer domain registration, shared hosting, VPS, and SSL certificates starting at affordable rates.

---

Final Thoughts

Snowflake and YTsaurus solve different problems. Snowflake is your easy-button cloud analytics platform—perfect for teams that want insights without operational burden. YTsaurus is a powerhouse for extreme-scale data processing—ideal for engineering-heavy organizations that need total flexibility and control.

Choose based on your data volume, team skills, and budget model. Both are excellent at what they're designed to do.

Building Modern Web Applications with Angular and PocketBase: A Complete Guide

 

In today's fast-paced development world, choosing the right tech stack can make or break your project timeline. While Angular remains one of the most powerful frontend frameworks, developers often struggle with backend setup complexity. Enter PocketBase – an open-source backend that gives you authentication, database, and file storage in a single file.

In this guide, I'll show you how to build a complete web application using Angular + PocketBase, combining the best of both worlds.

---

Why Angular + PocketBase?

Angular Benefits:

• Full-featured MVC framework with TypeScript support

• Built-in dependency injection

• Powerful CLI for scaffolding

• RxJS for reactive programming

• Enterprise-ready architecture

PocketBase Benefits:

• Single binary deployment (no complex setup)

• Embedded SQLite database

• Built-in authentication (email, OAuth2)

• Real-time subscriptions via Server-Sent Events (SSE)

• Automatic REST API generation

• Admin dashboard UI included

• File storage capabilities

Perfect For:

• MVPs and startups needing rapid development

• Internal tools and dashboards

• E-commerce applications

• Content management systems

• Real-time collaborative apps

---

Prerequisites

Before we begin, ensure you have:

• Node.js (v18 or later)

• Angular CLI (npm install -g @angular/cli)

• PocketBase executable (download from pocketbase.io)

• Basic knowledge of TypeScript and Angular

---

Step 1: Setting Up PocketBase

1. Download and Install

bash

# For Linux/Mac
wget https://github.com/pocketbase/pocketbase/releases/download/v0.22.0/pocketbase_0.22.0_linux_amd64.zip
unzip pocketbase_0.22.0_linux_amd64.zip

# For Windows
# Download the .exe file from GitHub releases

2. Start PocketBase

bash

./pocketbase serve

Your PocketBase server will run at http://127.0.0.1:8090. Visit the admin UI at http://127.0.0.1:8090/_/ and create your admin account.

3. Create Your First Collection
In the admin UI, create a new collection called posts with fields:

• title (text, required)

• content (text, required)

• published (boolean, default false)

• created (date, auto)

---

Step 2: Creating Angular Application

1. Generate New Angular Project

bash

ng new angular-pocketbase-app --style=css --routing
cd angular-pocketbase-app

2. Install PocketBase SDK

bash

npm install pocketbase

3. Create PocketBase Service
Generate a service to handle all PocketBase interactions:

bash

ng generate service services/pocketbase

4. Configure Environment Variables
Update src/environments/environment.ts:

typescript

export const environment = {
  production: false,
  pocketBaseUrl: 'http://127.0.0.1:8090'
};

---

Step 3: Building the PocketBase Service

src/app/services/pocketbase.service.ts

typescript

import { Injectable } from '@angular/core';
import PocketBase from 'pocketbase';
import { environment } from '../../environments/environment';

@Injectable({
  providedIn: 'root'
})
export class PocketbaseService {
  private pb: PocketBase;

  constructor() {
    this.pb = new PocketBase(environment.pocketBaseUrl);
  }

  // Authentication methods
  async login(email: string, password: string) {
    return await this.pb.collection('users').authWithPassword(email, password);
  }

  async register(email: string, password: string, passwordConfirm: string) {
    return await this.pb.collection('users').create({
      email,
      password,
      passwordConfirm
    });
  }

  logout() {
    this.pb.authStore.clear();
  }

  get currentUser() {
    return this.pb.authStore.model;
  }

  // Posts CRUD operations
  async getPosts() {
    return await this.pb.collection('posts').getFullList({
      sort: '-created',
      filter: 'published = true'
    });
  }

  async createPost(data: any) {
    return await this.pb.collection('posts').create(data);
  }

  async updatePost(id: string, data: any) {
    return await this.pb.collection('posts').update(id, data);
  }

  async deletePost(id: string) {
    return await this.pb.collection('posts').delete(id);
  }

  // Real-time subscriptions
  subscribeToPosts(callback: (data: any) => void) {
    return this.pb.collection('posts').subscribe('*', (e) => {
      callback(e);
    });
  }
}

---

Step 4: Creating Components

1. Posts List Component

bash

ng generate component posts-list

src/app/posts-list/posts-list.component.ts

typescript

import { Component, OnInit, OnDestroy } from '@angular/core';
import { PocketbaseService } from '../services/pocketbase.service';

@Component({
  selector: 'app-posts-list',
  templateUrl: './posts-list.component.html',
  styleUrls: ['./posts-list.component.css']
})
export class PostsListComponent implements OnInit, OnDestroy {
  posts: any[] = [];
  private unsubscribe: any;

  constructor(private pb: PocketbaseService) {}

  async ngOnInit() {
    await this.loadPosts();
    this.setupRealtime();
  }

  async loadPosts() {
    this.posts = await this.pb.getPosts();
  }

  setupRealtime() {
    this.unsubscribe = this.pb.subscribeToPosts((data) => {
      console.log('Realtime update:', data);
      this.loadPosts(); // Reload posts on any change
    });
  }

  ngOnDestroy() {
    if (this.unsubscribe) {
      this.unsubscribe();
    }
  }
}

src/app/posts-list/posts-list.component.html

html

<div class="posts-container">
  <h2>Latest Posts</h2>
  <div class="posts-grid">
    <div *ngFor="let post of posts" class="post-card">
      <h3>{{ post.title }}</h3>
      <p>{{ post.content }}</p>
      <small>Published: {{ post.created | date }}</small>
    </div>
  </div>
</div>

---

Step 5: Adding Authentication UI

1. Login Component

bash

ng generate component login

src/app/login/login.component.ts

typescript

import { Component } from '@angular/core';
import { Router } from '@angular/router';
import { PocketbaseService } from '../services/pocketbase.service';

@Component({
  selector: 'app-login',
  templateUrl: './login.component.html',
  styleUrls: ['./login.component.css']
})
export class LoginComponent {
  email = '';
  password = '';
  error = '';

  constructor(
    private pb: PocketbaseService,
    private router: Router
  ) {}

  async onSubmit() {
    try {
      await this.pb.login(this.email, this.password);
      this.router.navigate(['/posts']);
    } catch (err: any) {
      this.error = err.message || 'Login failed';
    }
  }
}

---

Step 6: Real-time Features with RxJS

PocketBase's real-time capabilities work beautifully with Angular's RxJS. Here's an enhanced service using Observables:

typescript

import { Observable } from 'rxjs';

// In pocketbase.service.ts
watchPosts(): Observable<any> {
  return new Observable((observer) => {
    const unsubscribe = this.pb.collection('posts').subscribe('*', (data) => {
      observer.next(data);
    });
    
    return () => unsubscribe();
  });
}

Now you can use this in components:

typescript

this.pb.watchPosts().subscribe(update => {
  console.log('Real-time update:', update);
  // Update your local data accordingly
});

---

Step 7: Deployment Considerations

Building Angular for Production

bash

ng build --prod

Deploying PocketBase

1. Upload PocketBase binary to your VPS or cloud server

2. Set up as a systemd service for auto-restart

3. Configure environment variables

4. Use Nginx as reverse proxy for SSL

Sample systemd service file:

ini

[Unit]
Description=PocketBase service

[Service]
Type=simple
User=youruser
WorkingDirectory=/opt/pocketbase
ExecStart=/opt/pocketbase/pocketbase serve --http=0.0.0.0:8090
Restart=on-failure

[Install]
WantedBy=multi-user.target

---

Step 8: Security Best Practices

1. Environment Variables: Never hardcode credentials

2. CORS Configuration: Configure PocketBase CORS properly

3. Validation Rules: Set collection validation rules in PocketBase admin

4. API Rules: Implement proper collection permissions

5. HTTPS: Always use SSL in production

---

Conclusion

Angular + PocketBase creates a powerful, modern stack that significantly reduces development time while maintaining scalability and performance. PocketBase handles all backend complexity, letting you focus on building amazing Angular applications.

Key Takeaways:

• PocketBase provides instant backend with zero configuration

• Angular offers robust structure for large applications

• Real-time features are simple to implement

• Perfect for startups and MVPs

• Open-source and self-hosted (no vendor lock-in)

---

Next Steps

• Explore PocketBase's file upload capabilities

• Implement OAuth authentication (Google, GitHub)

• Add search functionality

• Build an admin dashboard

• Deploy to production with Docker