How Bitscorp wired Firebase Analytics and RevenueCat into Grok MCP servers, then used agents to ship the habit-loop changes that moved PushUP Challenges from ~30 daily users to a 200–270 band.

From 30 to 270 DAU: Running PushUP with Grok, Firebase Analytics, and RevenueCat

---
title: "From 30 to 270 DAU: Running PushUP with Grok, Firebase Analytics, and RevenueCat"
date: "2026-08-20"
description: "How Bitscorp wired Firebase Analytics and RevenueCat into Grok MCP servers, then used agents to ship the habit-loop changes that moved PushUP Challenges from ~30 daily users to a 200–270 band."
slug: "grok-mcp-firebase-revenuecat-pushup-dau"
tags: "#grok #xai #mcp #firebase #revenuecat #reactnative #mobileanalytics #pushup"
author: "Bitscorp"
image: "/posts/grok-mcp-pushup-hero.jpg"
---

For years we treated analytics as a place we visited. Open Firebase on Monday. Open RevenueCat when a refund ticket appeared. Argue about a paywall on Friday. Ship something the following week, maybe.

That is not a production cycle. It is a museum of dashboards.

This year we put [xAI](https://x.ai/) Grok on the same side of the glass as the data. Grok talks to Firebase Analytics (GA4) and RevenueCat through MCP servers in one session, writes a ranked ship list, and hands the work to agents that edit the React Native app. Humans still review conversion-sensitive diffs. Everything else — diagnosis, scaffolding, tests, store metadata — runs inside that loop.

The headline on [PushUP Challenges](https://pushup.bitscorp.co/) is simple. Daily active users sat around **30**. They now live in a **200–270** band. Firebase is the DAU we quote internally. RevenueCat’s daily active-customer series, pulled through the same MCP, tells the same story with dates attached.

<figure>
  <img src="/posts/grok-mcp-pushup-hero.jpg" alt="A phone showing a push-up workout beside a monitor of live analytics traces" />
  <figcaption>The loop we actually run: a workout product on one screen, production telemetry on the other, Grok in the middle.</figcaption>
</figure>

## Dashboards were not a production loop

PushUP is a small habit app — push-ups, squats, challenges, camera counting, Screen Time Rewards — with a real store presence on [iOS](https://apps.apple.com/us/app/pushup-challenges/id6450053262) and [Android](https://play.google.com/store/apps/details?id=co.bitscorp.pushup). Subscriptions are a monthly and a yearly package on one RevenueCat offering. None of that is exotic.

What was exotic, in the bad sense, was the gap between “we can see the number” and “we changed the binary.”

A typical week used to look like this:

- Firebase: DAU is flat, `first_open` is fine, workout completion is not.
- RevenueCat: new customers keep arriving, paying conversion is a different conversation.
- Slack: a screenshot, a theory, no owner.
- The app: unchanged until someone carved out a “data day.”

We already had the two systems every serious mobile shop runs. **Firebase Analytics** for product events. **RevenueCat** for customers, trials, offerings, and money. They just did not talk to the people writing the code in the same hour.

MCP is the boring piece that fixed that. Grok can call tools. We pointed those tools at the same Analytics and RevenueCat projects we already pay for.

## What Grok actually reads

Two MCP servers sit in the Grok session we use for PushUP.

**Firebase Analytics, via the Google Analytics Data API.** Firebase events land in GA4. From Grok we run reports and funnels: DAU, `first_open` → onboarding → first completed set → challenge join → paywall view. We do not paste CSV into chat. We ask, the tool returns rows, Grok keeps going.

**RevenueCat.** Overview metrics for the last 28 days, daily active customers, new customers, offerings, packages, and category benchmarks. Same session, same customer identity space as the stores.

A stripped config looks like this — keys stay in the MCP client, never in the repo:

```json
{
  "mcpServers": {
    "analytics": {
      "command": "npx",
      "args": ["-y", "@google/analytics-mcp"]
    },
    "revenuecat": {
      "url": "https://mcp.revenuecat.com/mcp",
      "headers": {
        "Authorization": "Bearer $REVENUECAT_API_KEY"
      }
    }
  }
}
```

The prompt we start most mornings with is not clever. It is specific:

```text
Pull PushUP Firebase DAU and the workout / challenge funnel for the last 28 days.
Pull RevenueCat overview metrics and daily active customers for the same window.
Join them. Tell me whether the problem is acquisition, first session, return habit, or paywall.
Give me at most three shippable changes, ranked by expected DAU, with the event names we should watch after release.
```

Grok does not “have a feeling about engagement.” It reads both sources, notices when they disagree, and has to explain the disagreement before it is allowed to recommend a diff.

## The diagnosis that changed the ship list

The joined picture in July was uncomfortable, and useful.

Acquisition was not the fire. RevenueCat recorded **more than 4,000 new customers in 28 days** across App Store and Play. People were finding PushUP.

The fire was what happened after day zero. Firebase DAU sat near **30**. RevenueCat’s daily active-customer series opened on **19 July at 24**. For the next ten days it bounced in the 60–130 range — a live product with no daily reason to open it.

That is a habit-loop problem, not a user-acquisition problem. Shipping another paywall experiment would have been the wrong next move. The ranked list Grok came back with was, in order:

1. **Shorten time-to-first-rep.** Camera counting so a session is a set, not a form.
2. **Pay the user for coming back tomorrow.** Screen Time Rewards — reps become minutes of selected apps.
3. **Give the day a social object.** Challenges, not just a private counter.
4. **Stop the paywall from eating the first workout.** Let someone complete a set before they see a wall.

That ordering is the whole point of joining Firebase to RevenueCat in one model. If you only look at RevenueCat, you reach for conversion. If you only look at Firebase, you reach for “more notifications.” Together, the recommendation was: **earn the second day before you sell the month.**

## The loop we run now

<figure>
  <img src="/posts/pushup-mcp-loop.svg" alt="Four-step loop: observe with MCP, diagnose in Grok, ship with agents, measure again" />
  <figcaption>Observe → diagnose → ship → measure. Same tools on the way in and the way out.</figcaption>
</figure>

**1. Observe.** Grok pulls GA4 reports and RevenueCat charts. No tab-hopping. The session holds both payloads.

**2. Diagnose.** One ranked list, with the event or metric that will prove each item. If Grok cannot name the event, the item does not ship.

**3. Ship.** Specialized agents take the list into the React Native repo. One agent implements. A second reviews. A third updates store copy when the change is user-facing. We still type the last “yes” on paywall and pricing.

**4. Measure.** The next morning the same MCP calls run again. Keep, iterate, or revert. The chart below is that loop, not a campaign spike.

We described the camera and rewards work when it landed — [Screen Time Rewards and camera rep counting](/blog/big-update-screen-time-rewards-camera-rep-counting-are-live). What that post did not say is that those features were not a brainstorm. They were the first two items on a Grok ship list that started with a 24-user Tuesday.

## What the agents actually changed

Agents are not a vibe. They are scoped workers with the repo, the simulator, and a done condition.

For PushUP the useful ones were:

- A **mobile** agent for React Native screens, VisionCamera pose counting, and the rewards award path.
- A **review** agent that is not allowed to be the one that wrote the diff.
- A **store** agent for App Store / Play text when the habit loop changed.

The code that fell out is ordinary. That is the compliment. Camera counting is an elbow-angle state machine, not a manifesto:

```ts
if (phaseRef.current === "down" && elbowAngle >= UP_ELBOW_ANGLE) {
  countRef.current += 1;
  setCount(countRef.current);
}
```

Rewards only fire when the session was real and the entitlement is real:

```ts
if (Platform.OS === "ios" && isPremium && screenTimeEnabled) {
  awardMinutes(Math.round(value * minutesPerRep));
}
```

Grok’s job was not to invent that logic. It was to insist this logic was the next production change, because Firebase said first-rep was the drop-off and RevenueCat said new customers were already walking in the door.

We still refuse a few automations on purpose:

- No agent may change prices, package lookup keys, or offering mapping.
- No agent may merge to `production` without a human.
- No agent may “fix” a funnel by deleting an event.

Those rules are why we can run this loop on a live store app instead of a demo.

## The numbers

Firebase DAU is the number we used internally: **about 30**, then a stable **200–270**.

RevenueCat daily active customers — customers seen that day, purchased or not — is the series we can date. Pulled live from the same MCP this article is about:

<figure>
  <img src="/posts/pushup-dau-chart.svg" alt="Line chart of PushUP daily active customers from 19 July to 19 August 2026, stepping from 24 into a 200 to 270 band" />
  <figcaption>RevenueCat daily active customers, 19 July – 19 August 2026. 24 on day one. 196 on 29 July. A 200–270 band through August, with a 311 spike on 31 July.</figcaption>
</figure>

<table>
  <thead>
    <tr>
      <th>Window</th>
      <th>What we saw</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>19 Jul</td>
      <td>24 RevenueCat active customers. Firebase DAU ~30.</td>
    </tr>
    <tr>
      <td>19–28 Jul</td>
      <td>Noisy 60–130. Product is alive; the daily habit is not.</td>
    </tr>
    <tr>
      <td>29 Jul onward</td>
      <td>Step change: 196, then a 200–270 band (avg ~229). Spike of 311 on 31 Jul.</td>
    </tr>
    <tr>
      <td>Last 28 days</td>
      <td>4,400+ new RevenueCat customers. Acquisition was never the bottleneck.</td>
    </tr>
  </tbody>
</table>

A 7–9× DAU move on a fitness habit app is not “we ran ads.” Ads would have shown up as new customers without a second-day return. We already had the new customers. The loop spent them on a reason to open the app tomorrow.

Monetization is the next loop, not this one. Monthly and yearly packages exist. Conversion is still a health-and-fitness-benchmark problem. We will not pretend DAU and ARPU moved together. They did not. That is why the next Grok prompt is about trial start and first-paywall after a completed set — not about another onboarding animation.

## Why Grok, specifically

We have used other coding agents. The reason this loop lives in Grok is mechanical:

- **MCP in the same turn as the code.** Analytics rows and a React Native file are one conversation, not an export plus a paste.
- **Long enough context** to hold a funnel table, a 30-day series, and the current screen without losing the event names.
- **Agents as a second pair of hands**, not as a replacement for the session that understood the data.

xAI is in the production development cycle the same way EAS and RevenueCat are: as infrastructure. We do not prompt Grok to “make the app grow.” We prompt it to read the two systems of record and refuse to ship the third idea on the list until the first two have a metric.

## What we would repeat on the next app

The Play Stream, language apps, and health tools in the same RevenueCat org can run this tomorrow. The recipe is short:

1. Instrument a small event list. If you cannot name `first_open`, first successful action, and paywall view, stop.
2. Put GA4 and RevenueCat on MCP. One Grok project, one pair of servers.
3. Start the day with the join prompt. End the day with at most three diffs.
4. Measure on the same tools you diagnosed with. If the metric did not move, revert.

That is the success story. Not a model that “understands fitness.” A studio that stopped treating Firebase and RevenueCat as reports, and started treating them as the first function call in a shipping loop.

PushUP is still a small app. 200–270 daily users is a band we can hold, not a ceiling we are bragging about. It is also not 30. The difference is the loop.

**[Train with PushUP](https://pushup.bitscorp.co/)** · **[Build this loop for your app](/contact)**


PushUP now includes Screen Time Rewards and camera-based push-up counting with a VisionCamera pose pipeline to make workouts automatic, motivating, and habit-friendly.

Big Update: Screen Time Rewards + Camera Rep Counting Are Live

---
title: "Big Update: Screen Time Rewards + Camera Rep Counting Are Live"
date: "2026-03-04"
description: "PushUP now includes Screen Time Rewards and camera-based push-up counting with a VisionCamera pose pipeline to make workouts automatic, motivating, and habit-friendly."
slug: "big-update-screen-time-rewards-camera-rep-counting-are-live"
tags: "#mobileapp #reactnative #visioncamera #healthtech #fitness"
---

# Big Update: Screen Time Rewards + Camera Rep Counting Are Live

One of our biggest PushUP releases is now live.

We launched two features built to help users stay consistent, stay motivated, and make workouts feel rewarding every day:

- **Screen Time Rewards system**
- **Camera-based push-up counting** powered by our VisionCamera pose pipeline

This release is focused on one core idea: training should be simple, automatic, and worth it.

## Why we built this

Many people want to train more consistently, but daily motivation is often the hardest part.
Instead of adding more reminders, we connected effort to a real reward.

Now users can complete push-ups (and other exercises), earn minutes, and unlock selected apps with that effort.
It turns "I should train" into "I get something right now if I train."

## 1) Screen Time Rewards system

Users can define how much each rep is worth.  
Example:

- `1 rep = 1 minute`

After a completed activity, earned minutes are awarded and applied to the reward flow.

```ts
if (Platform.OS === "ios" && isPremium && screenTimeEnabled) {
  awardMinutes(Math.round(value * minutesPerRep));
}
```

This creates a clear habit loop:

1. Train
2. Earn
3. Unlock

Simple flow, strong motivation.

## 2) Count push-ups with camera

We also shipped camera counting so users no longer need to manually enter reps.
The app tracks body keypoints and counts reps based on movement phase and elbow-angle logic.

```ts
if (phaseRef.current === "down" && elbowAngle >= UP_ELBOW_ANGLE) {
  countRef.current += 1;
  setCount(countRef.current);
}
```

This creates a smoother workout experience:

- Start camera
- Do push-ups
- Let the app count automatically

No manual tapping while training.

## Better together

The real impact comes from combining both systems:

- Camera counting removes friction
- Rewards add motivation
- Users get instant feedback and a reason to come back tomorrow

This combination helps users stay more consistent with both push-ups and other exercises in PushUP.

## Download the app

Try the new experience here:

**[https://pushup.bitscorp.co/](https://pushup.bitscorp.co/)**

If you’ve already been training with PushUP, thank you.
This release is a major step forward, and we’re just getting started.


A complete guide to setting up world-class monitoring for your Elixir and Phoenix applications from day one using Prometheus and the PromEx library.

Proactive Elixir Monitoring with Prometheus and PromEx

---
title: "Proactive Elixir Monitoring with Prometheus and PromEx"
date: "2025-11-20"
description: "A complete guide to setting up world-class monitoring for your Elixir and Phoenix applications from day one using Prometheus and the PromEx library."
slug: "proactive-elixir-monitoring-prometheus-promex"
tags: "#elixir #phoenix #prometheus #monitoring #observability #prom_ex #devops"
published: true
---

Deploying an application without monitoring is like flying a plane without instruments. You might be flying, but you have no idea if you're about to run out of fuel or if an engine is on fire. In modern software development, **observability** is not an optional add-on; it's a fundamental requirement for building reliable and performant systems.

At Bitscorp, we believe in integrating monitoring from the very beginning of a project. In the Elixir ecosystem, the combination of **Prometheus** and the **`prom_ex`** library makes this incredibly easy and powerful.

## Why Add Monitoring from Day One?

Many teams treat monitoring as an afterthought, something to be bolted on once the "real" features are built. This is a critical mistake. Here’s why you should start from day one:

1.  **Establish a Performance Baseline**: You can't identify a performance regression if you don't know what "normal" looks like. Early monitoring gives you a baseline for key metrics like response times, database queries, and memory usage.

2.  **Catch Issues Early**: Did a recent deploy introduce a memory leak or make a database query ten times slower? With proper monitoring, you'll spot these anomalies immediately, not after your users start complaining.

3.  **Make Data-Driven Decisions**: Instead of guessing where performance bottlenecks are, you'll have concrete data to guide your optimization efforts. This saves countless hours of premature or misdirected optimization.

4.  **Build a Culture of Observability**: When metrics are integrated into the development process, the entire team becomes more aware of performance and reliability. It encourages developers to think about the operational impact of their code as they write it.

## The Solution: Prometheus + PromEx

**Prometheus** is an open-source monitoring and alerting toolkit that has become the industry standard for collecting time-series data. It works on a "pull" model, where it periodically scrapes an HTTP endpoint (usually `/metrics`) on your application to collect metrics.

**`prom_ex`** is a brilliant Elixir library that acts as a "batteries-included" instrumentation solution. It not only exposes your application's metrics in a Prometheus-compatible format but also bundles pre-built plugins for the most common parts of the Elixir/Phoenix stack, including:
*   The BEAM (Erlang VM)
*   Phoenix (requests, response times)
*   Ecto (database query times, connection pool usage)
*   Absinthe (GraphQL)
*   And more... 

It even comes with pre-built Grafana dashboards, giving you a world-class monitoring setup with minimal effort.

## Step-by-Step Integration Guide

Let's walk through how to add `prom_ex` to a standard Phoenix project.

### Step 1: Add Dependencies

First, add `prom_ex` and a Prometheus-client dependency to your `mix.exs`:

```elixir
def deps do
  [
    # ... other dependencies
    {:prom_ex, "~> 1.9"},
    # You need to choose a client. :prometheus_telemetry is a great default.
    {:prometheus_telemetry, "~> 1.1"}
  ]
end
```

Then, run `mix deps.get` to fetch them.

### Step 2: Create Your Metrics Module

`prom_ex` works by having you define a central metrics module. This is where you configure which plugins to use and define any custom metrics.

Create a new file at `lib/my_app/metrics.ex`:

```elixir
defmodule MyApp.Metrics do
  use PromEx, otp_app: :my_app

  @impl true
  def plugins do
    [
      # Provides BEAM memory, scheduler, and process metrics
      PromEx.Plugins.Beam,

      # Provides Phoenix metrics like request duration and counts
      {PromEx.Plugins.Phoenix, router: MyAppWeb.Router, endpoint: MyAppWeb.Endpoint},

      # Provides Ecto metrics like query times and pool usage
      {PromEx.Plugins.Ecto, repos: Application.fetch_env!(:my_app, :ecto_repos)},

      # If you use Oban for background jobs
      # {PromEx.Plugins.Oban, oban_config: Application.fetch_env!(:my_app, Oban)}
    ]
  end
end
```

### Step 3: Configure `prom_ex`

Now, tell `prom_ex` about your new module in `config/config.exs`:

```elixir
import Config

config :my_app, PromEx,
  metrics_modules: [MyApp.Metrics]
```

### Step 4: Add to Your Application's Supervision Tree

For your metrics server to start when your application starts, add it to the children list in `lib/my_app/application.ex`:

```elixir
defmodule MyApp.Application do
  use Application

  @impl true
  def start(_type, _args) do
    children = [
      # ... other children
      MyApp.Metrics
    ]

    # ...
    Supervisor.start_link(children, strategy: :one_for_one, name: MyApp.Supervisor)
  end
end
```

### Step 5: Expose the `/metrics` Endpoint

Prometheus needs an endpoint to scrape. Expose it by adding the `PromEx` plug to your `lib/my_app_web/endpoint.ex` file, ideally before the `Plug.RequestId` plug:

```elixir
defmodule MyAppWeb.Endpoint do
  use Phoenix.Endpoint, otp_app: :my_app

  # ...

  plug PromEx.Plug, metrics_modules: [MyApp.Metrics]
  plug Plug.RequestId
  plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]

  # ...
end
```

At this point, if you start your Phoenix server (`mix phx.server`), you can visit `http://localhost:4000/metrics` and see a wall of Prometheus-formatted metrics!

## Creating Custom Application Metrics

The real power of monitoring comes from tracking metrics specific to your application's domain. Let's say we want to count the number of new user registrations.

First, define the metric in your `MyApp.Metrics` module. A `Counter` is perfect for this.

```elixir
# In lib/my_app/metrics.ex

defmodule MyApp.Metrics do
  use PromEx, otp_app: :my_app

  # ... existing plugins function

  @impl true
  def custom_metrics() do
    [
      Counter.new(
        name: :user_registered_total,
        help: "Total number of registered users.",
        labels: [:source] # Optional: e.g., [:web, :api, :import]
      )
    ]
  end
end
```

Now, from anywhere in your application, you can increment this counter. For example, in your `Accounts` context, right after a user is successfully created:

```elixir
# In lib/my_app/accounts/accounts.ex

def register_user(attrs \\ %{}) do
  with {:ok, %User{} = user} <- 
         %User{}`
         |> User.registration_changeset(attrs)
         |> Repo.insert() do

    # Increment our custom metric!
    MyApp.Metrics.increment(:user_registered_total, 1, labels: %{source: :web})

    {:ok, user}
  end
end
```
Now, every time a new user registers, your `my_app_user_registered_total` metric will increase, and you can track user growth in real-time.

## Conclusion

With just a few lines of code, `prom_ex` provides a level of insight into your Elixir application that would have taken weeks to build manually. By integrating monitoring from day one, you empower your team to build more reliable, performant, and robust applications. You're no longer flying blind; you have a full dashboard of instruments to guide you.

For us at Bitscorp, `prom_ex` is a "day one" dependency on every new Elixir project. The value it provides in terms of operational insight and developer confidence is immeasurable.

---

*Ready to bring world-class observability to your Elixir projects? If you need help setting up advanced monitoring, data pipelines, or building scalable Elixir applications, [get in touch with us today](/contact)!*


Learn how to implement the circuit breaker pattern in Go using the gobreaker library to build resilient and fault-tolerant microservices, with a practical example for handling payment requests.

Building Resilient Microservices: The Circuit Breaker Pattern in Go with Gobreaker

---
title: "Building Resilient Microservices: The Circuit Breaker Pattern in Go with Gobreaker"
date: "2025-11-15"
description: "Learn how to implement the circuit breaker pattern in Go using the gobreaker library to build resilient and fault-tolerant microservices, with a practical example for handling payment requests."
slug: "circuit-breaker-pattern-golang-gobreaker"
tags: "#golang #gobreaker #microservices #resilience #design-patterns #fault-tolerance"
---

In modern microservices architectures, services often depend on one another. But what happens when one service fails or becomes slow? It can trigger a cascade of failures, bringing down your entire system. To prevent this, we can implement the **Circuit Breaker** design pattern, which is essential for building resilient, fault-tolerant applications.

At Bitscorp, we use this pattern to protect our services, and `gobreaker` is our preferred library for implementing it in Go.

## What is the Circuit Breaker Pattern?

The Circuit Breaker pattern is modeled after a real-world electrical circuit breaker. It wraps a protected function call (like a network request) in a state machine that monitors for failures. It has three states:

1.  **Closed**: The initial state. Requests are allowed to pass through to the protected service. The circuit breaker counts the number of failures, and if they exceed a certain threshold within a time window, it "trips" and moves to the **Open** state.

2.  **Open**: For a configured timeout period, all requests to the protected service fail immediately without even attempting to execute. This prevents the application from repeatedly calling a service that is likely down. After the timeout, the circuit breaker moves to the **Half-Open** state.

3.  **Half-Open**: In this state, a limited number of test requests are allowed to pass through. If these requests succeed, the circuit breaker resets and returns to the **Closed** state. If any request fails, it trips back to the **Open** state to begin the timeout period again.

This pattern prevents cascading failures and allows a failing service time to recover.

## Implementing a Circuit Breaker in Go with `gobreaker`

[gobreaker](https://github.com/sony/gobreaker) is a simple and effective Go library for implementing the circuit breaker pattern. Let's walk through an example of wrapping a potentially failing payment request.

### The Scenario: A Flaky Payment Gateway

Imagine we have a payment service that communicates with an external gateway. This gateway is sometimes unavailable, causing our requests to time out or fail. We want to prevent our application from getting stuck waiting for a response and avoid bombarding the gateway when it's already struggling.

### Installation

First, add `gobreaker` to your project:

```bash
go get github.com/sony/gobreaker
```

### Example Implementation

Here’s a complete example demonstrating how to use `gobreaker` to protect a payment request function.

```go
package main

import (
	"errors"
	"fmt"
	"log"
	"math/rand"
	"time"

	"github.com/sony/gobreaker"
)

// simulatePaymentGateway simulates making a request to an external payment gateway.
// To demonstrate the circuit breaker, it will fail randomly.
func simulatePaymentGateway(amount float64) (string, error) {
	// Fail 60% of the time to simulate an unreliable service.
	if rand.Intn(100) < 60 {
		return "", errors.New("payment gateway is unavailable")
	}

	return fmt.Sprintf("payment of $%.2f successful", amount), nil
}

func main() {
	// Configure the circuit breaker settings.
	settings := gobreaker.Settings{
		Name:        "PaymentGateway",
		MaxRequests: 3, // Number of requests allowed in Half-Open state.
		Interval:    5 * time.Second, // The cyclical period of the 'Closed' state.
		Timeout:     10 * time.Second, // The period of the 'Open' state.
		// This function is called when the state changes.
		OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
			log.Printf("Circuit Breaker '%s' changed state from %s to %s\n", name, from, to)
		},
	}

	// Create a new CircuitBreaker with the defined settings.
	cb := gobreaker.NewCircuitBreaker(settings)

	// Simulate making multiple payment requests.
	for i := 1; i <= 20; i++ {
		paymentAmount := 50.00
		
		// The Execute function wraps our protected call.
		body, err := cb.Execute(func() (interface{}, error) {
			return simulatePaymentGateway(paymentAmount)
		})

		if err != nil {
			log.Printf("Request #%d: FAILED. Error: %v (Circuit Breaker State: %s)", i, err, cb.State())
		} else {
			log.Printf("Request #%d: SUCCESS. Response: %s (Circuit Breaker State: %s)", i, body, cb.State())
		}

		// Wait a bit between requests.
		time.Sleep(500 * time.Millisecond)
	}
}

```

### How It Works

1.  **Configuration**: We create a `gobreaker.Settings` struct.
    *   `MaxRequests`: When the circuit is `Half-Open`, it allows 3 requests to pass through to test if the service has recovered.
    *   `Interval`: In the `Closed` state, the failure counts are reset after this interval (5 seconds).
    *   `Timeout`: When the circuit is `Open`, it will stay open for 10 seconds before transitioning to `Half-Open`.
    *   `OnStateChange`: A useful callback to log state transitions, which is great for monitoring.

2.  **Execution**: We wrap our `simulatePaymentGateway` call inside `cb.Execute()`.
    *   `gobreaker` monitors the return value of this function. If it returns an error, it counts it as a failure.
    *   When the circuit is **Closed**, `Execute` calls our function. After enough failures, it opens the circuit.
    *   When the circuit is **Open**, `Execute` immediately returns `gobreaker.ErrOpenState` without running our function.
    *   After the `Timeout`, the state becomes **Half-Open**, and `Execute` lets a few requests (`MaxRequests`) through. Successes will close the circuit, while any failure will re-open it.

### Example Output

Running the code above might produce output like this:

```
2025/11/15 10:30:01 Request #1: FAILED. Error: payment gateway is unavailable (Circuit Breaker State: closed)
2025/11/15 10:30:01 Request #2: SUCCESS. Response: payment of $50.00 successful (Circuit Breaker State: closed)
2025/11/15 10:30:02 Request #3: FAILED. Error: payment gateway is unavailable (Circuit Breaker State: closed)
2025/11/15 10:30:03 Request #4: FAILED. Error: payment gateway is unavailable (Circuit Breaker State: closed)
2025/11/15 10:30:03 Request #5: FAILED. Error: payment gateway is unavailable (Circuit Breaker State: closed)
2025/11/15 10:30:04 Request #6: FAILED. Error: payment gateway is unavailable (Circuit Breaker State: closed)
2025/11/15 10:30:04 Circuit Breaker 'PaymentGateway' changed state from closed to open
2025/11/15 10:30:04 Request #7: FAILED. Error: circuit breaker is open (Circuit Breaker State: open)
2025/11/15 10:30:05 Request #8: FAILED. Error: circuit breaker is open (Circuit Breaker State: open)
... (fails immediately for 10 seconds) ...
2025/11/15 10:30:14 Circuit Breaker 'PaymentGateway' changed state from open to half-open
2025/11/15 10:30:14 Request #15: FAILED. Error: payment gateway is unavailable (Circuit Breaker State: half-open)
2025/11/15 10:30:14 Circuit Breaker 'PaymentGateway' changed state from half-open to open
2025/11/15 10:30:15 Request #16: FAILED. Error: circuit breaker is open (Circuit Breaker State: open)

```
As you can see, once the gateway is deemed unhealthy, the circuit breaker opens and starts failing requests fast, protecting both our application and the downstream service.

## Why This Matters

By implementing the circuit breaker pattern, you achieve:
*   **Resilience**: Your application can gracefully handle failures in downstream services without crashing.
*   **Fault Tolerance**: You prevent a single point of failure from causing a system-wide outage.
*   **Better User Experience**: Users get a faster response (an error message) instead of a long wait, and the system recovers automatically.

For any distributed system, especially in a microservices environment, the circuit breaker pattern is not just a "nice-to-have"—it's a necessity for building robust, production-grade services.

---

*Need help building resilient, scalable backend systems in Go? [Contact us today](/contact) to discuss how we can help you implement best-practice design patterns for your next project.*


Learn how connecting Google Ads and Firebase data in BigQuery can supercharge your mobile app marketing.

Why Mobile Devs Should Care About Google BigQuery

---
title: 'Why Mobile Devs Should Care About Google BigQuery'
description: 'Learn how connecting Google Ads and Firebase data in BigQuery can supercharge your mobile app marketing.'
date: '2025-10-25'
image: '/public/posts/bigquery-mobile.png'
slug: 'google-bigquery-for-mobile-dev'
tags: '#bigquery #firebase #google-ads #mobile-development #data-analysis'
published: true
---

Hey mobile devs!

We often think of our job as being all about crafting beautiful UIs and smooth user experiences. But what happens after the app is launched? How do we know if our marketing efforts are actually paying off? That's where a powerful tool like Google BigQuery can make a huge difference.

If you're running a mobile development company, you're likely using various services to acquire and understand your users. Two of the most common are:

*   **Google Ads:** For running user acquisition campaigns.
*   **Firebase Analytics:** For tracking in-app events and user behavior.

Both of these are fantastic on their own, but the real magic happens when you bring their data together. And that's where BigQuery comes in.

### The Power of Connected Data

By linking your Google Ads and Firebase accounts to BigQuery, you can get a unified view of your entire user journey. You can track a user from the moment they click on an ad to the specific actions they take within your app. This is a game-changer for optimizing your ad spend. A key benefit of this integration is the ability to use specific Firebase events as conversion goals in your Google Ads campaigns, allowing for more targeted and effective advertising.

Imagine being able to answer questions like:

*   "Which ad campaign is bringing in the users who are most likely to make an in-app purchase?"
*   "What's the average lifetime value of a user acquired from a specific ad creative?"
*   "Are users from a certain geographical location more engaged with a particular feature?"

With BigQuery, you can answer these questions and more.

### A Simple BigQuery Example

Let's say you want to find out which of your ad campaigns are bringing in the most engaged users, based on a custom event you've set up in Firebase called `level_completed`. Your query in BigQuery might look something like this:

```sql
SELECT
  ad_campaign.name AS campaign_name,
  COUNT(DISTINCT user.user_id) AS engaged_users
FROM
  `your_project.firebase_events.events_*` AS events
JOIN
  `your_project.google_ads.ad_clicks` AS ads
  ON events.user_id = ads.user_id
WHERE
  events.event_name = 'level_completed'
GROUP BY
  campaign_name
ORDER BY
  engaged_users DESC;
```

This query joins your Firebase event data with your Google Ads data and gives you a list of campaigns ranked by the number of users who have completed a level in your game. This kind of insight is invaluable for deciding where to allocate your marketing budget.

### Why Bother?

By leveraging BigQuery, you can:

*   **Make data-driven decisions:** Stop guessing and start making informed choices about your marketing strategy.
*   **Improve ROI:** Focus your ad spend on the campaigns that deliver the most valuable users.
*   **Understand your users better:** Get a deeper understanding of how users interact with your app.

### We Can Help!

Feeling a bit overwhelmed by all this data talk? Don't worry, we've got you covered. At Bitscorp, we specialize in both mobile development and data analysis. We can help you set up your data pipelines, build insightful dashboards, and make the most of the data you're already collecting.

**[Ready to level up your mobile marketing? Get in touch with us today!](/contact)**


A brief overview of how we use Apache Airflow to automate our reporting workflows, leveraging Hive and PostgreSQL.

Automating Reports with Airflow, Hive, and PostgreSQL

---
title: 'Automating Reports with Airflow, Hive, and PostgreSQL'
description: 'A brief overview of how we use Apache Airflow to automate our reporting workflows, leveraging Hive and PostgreSQL.'
date: '2025-10-24'
image: '/public/posts/airflow-automation.png'
slug: "airflow-data-automation-hive-postgres"
tags: "#data-engineering #airflow #hive #postgresql #automation"
published: true
---

Hey everyone,

We wanted to share a little bit about how we've been using some cool open-source tools to automate our data-heavy tasks. If you're drowning in data and manual reports, you might find this interesting.

At Bitscorp, we handle a lot of data from various sources, and one of the key parts of our workflow is generating reports for our clients and for our internal use. Manually running queries and compiling reports is not just tedious, but also prone to errors. That's where [Apache Airflow](https://airflow.apache.org/) comes in.

### Our Data Stack for Automation

We've found a pretty sweet spot with the following combination:

*   **Amazon S3:** Our data lands in S3 buckets, partitioned by date. This is pretty standard, but it's a reliable way to store and organize large volumes of data.
*   **Apache Hive:** We use Hive to run SQL-like queries on the data stored in S3. It's great for those big data processing jobs.
*   **PostgreSQL:** This is where we store the results of our Hive queries. It's our go-to for a reliable, easy-to-use database for the final, aggregated data.
*   **Apache Airflow:** This is the conductor of our orchestra. Airflow lets us define our workflows as code (Python, to be specific) and schedules them to run automatically.

### A Quick Look at an Airflow DAG

Here’s a simplified example of what an Airflow DAG (Directed Acyclic Graph) looks like for our process. This DAG defines the tasks and their dependencies.

```python
from airflow import DAG
from airflow.providers.apache.hive.operators.hive import HiveOperator
from airflow.providers.postgres.operators.postgres import PostgresOperator
from airflow.utils.dates import days_ago

with DAG(
    dag_id='daily_report_generator',
    schedule_interval='@daily',
    start_date=days_ago(1),
    catchup=False,
) as dag:

    # Task to run a Hive query to process data from S3
    process_data = HiveOperator(
        task_id='process_data_from_s3',
        hql="""
            INSERT OVERWRITE TABLE processed_reports
            SELECT ...
            FROM raw_data
            WHERE date = '{{ ds }}';
        """,
    )

    # Task to copy the processed data to PostgreSQL
    store_results = PostgresOperator(
        task_id='store_results_in_postgres',
        sql="""
            TRUNCATE TABLE daily_reports;
            INSERT INTO daily_reports
            SELECT * FROM processed_reports;
        """,
    )

    process_data >> store_results
```

In this example, `process_data` runs a Hive query to transform the raw data, and once it's done, `store_results` takes over to copy the data into our PostgreSQL database. Airflow makes sure this runs every day, and it'll even retry if something fails.

### Why We Like It

This setup gives us:

*   **Automation:** No more manual query running.
*   **Reliability:** Airflow has great logging and retry mechanisms.
*   **Scalability:** This stack can handle a growing amount of data.
*   **Flexibility:** We can add more complex steps and integrations as needed.

### Need Help with Your Data?

If you're looking to build out your own data pipelines, automate your reporting, or just need a hand with data analysis, we'd love to help. We have a lot of experience in this area and can get you up and running quickly.

**[Contact us today to discuss your data challenges!](/contact)**


Transform your app idea into reality with our comprehensive package covering mobile & web development, store publication, marketing strategies, and intelligent automation using n8n and OpenAI. Delivered in clear milestones with actionable results.

Complete Mobile & Web App Development: From Concept to Store Publish with Marketing & Automation

Discover how we built a comprehensive AI-powered knowledge base chat system using LLMs, RAG architecture, vector databases, and automated reindexing with intelligent reporting communication.

Building an Intelligent Knowledge Base Chat System: RAG, Vector Search, and Automated Reporting

Complete guide to integrating RevenueCat with React Native for seamless subscription management across iOS and Android. Learn implementation strategies, advantages, and best practices we use across all our mobile apps.

React Native RevenueCat Integration: Streamlined Subscription Management for iOS and Android

---
title: "React Native RevenueCat Integration: Streamlined Subscription Management for iOS and Android"
date: "2025-08-09"
description: "Complete guide to integrating RevenueCat with React Native for seamless subscription management across iOS and Android. Learn implementation strategies, advantages, and best practices we use across all our mobile apps."
slug: "react-native-revenuecat-integration"
tags: "#reactnative #revenuecat #subscriptions #ios #android #mobile #monetization"
---

# React Native RevenueCat Integration: Streamlined Subscription Management for iOS and Android

Managing subscriptions across iOS and Android can be complex and time-consuming. After implementing subscription systems in numerous mobile apps, we've standardized on RevenueCat for all our React Native projects. Here's why RevenueCat has become our go-to solution and how to integrate it effectively.

## Why RevenueCat for React Native?

### Cross-Platform Consistency

RevenueCat eliminates platform-specific subscription logic, providing a unified API that works seamlessly across iOS App Store and Google Play Store:

```javascript
// Single API call works on both platforms
const purchaseResult = await Purchases.purchaseProduct('premium_monthly');
```

Instead of maintaining separate StoreKit (iOS) and Google Play Billing (Android) implementations, RevenueCat abstracts platform differences into one consistent interface.

### Real-Time Subscription Analytics

RevenueCat's dashboard provides comprehensive insights into:
- Monthly Recurring Revenue (MRR)
- Churn rates and retention metrics
- Trial conversion rates
- Revenue by country and platform
- Customer lifetime value (LTV)

This data is crucial for optimizing subscription funnels and pricing strategies.

## Implementation: Getting Started

### Installation & Setup

Install the RevenueCat React Native SDK:

```bash
npm install react-native-purchases
cd ios && pod install # iOS only
```

### Basic Configuration

Initialize RevenueCat in your app's entry point:

```javascript
import Purchases from 'react-native-purchases';

// Configure RevenueCat
const configureRevenueCat = async () => {
  if (Platform.OS === 'ios') {
    await Purchases.configure({ apiKey: 'your_ios_api_key' });
  } else if (Platform.OS === 'android') {
    await Purchases.configure({ apiKey: 'your_android_api_key' });
  }
};

// Call during app initialization
useEffect(() => {
  configureRevenueCat();
}, []);
```

### Product Fetching & Display

Retrieve subscription products from your configured offerings:

```javascript
const [offerings, setOfferings] = useState(null);
const [loading, setLoading] = useState(true);

useEffect(() => {
  const fetchOfferings = async () => {
    try {
      const offerings = await Purchases.getOfferings();
      setOfferings(offerings);
    } catch (error) {
      console.error('Error fetching offerings:', error);
    } finally {
      setLoading(false);
    }
  };

  fetchOfferings();
}, []);

// Display subscription options
const renderSubscriptionOptions = () => {
  if (!offerings?.current) return null;

  return offerings.current.availablePackages.map((pkg) => (
    <TouchableOpacity 
      key={pkg.identifier}
      onPress={() => handlePurchase(pkg)}
      style={styles.subscriptionOption}
    >
      <Text style={styles.title}>{pkg.product.title}</Text>
      <Text style={styles.price}>{pkg.product.priceString}</Text>
      <Text style={styles.description}>{pkg.product.description}</Text>
    </TouchableOpacity>
  ));
};
```

### Purchase Implementation

Handle subscription purchases with comprehensive error handling:

```javascript
const handlePurchase = async (packageToPurchase) => {
  try {
    setLoading(true);
    
    const { customerInfo } = await Purchases.purchasePackage(packageToPurchase);
    
    // Check subscription status
    if (customerInfo.entitlements.active['premium']) {
      // User now has premium access
      navigation.navigate('PremiumContent');
    }
  } catch (error) {
    if (!error.userCancelled) {
      // Handle purchase errors
      Alert.alert('Purchase Error', error.message);
    }
  } finally {
    setLoading(false);
  }
};
```

### Subscription Status Management

Create a subscription context for app-wide access:

```javascript
import React, { createContext, useContext, useState, useEffect } from 'react';
import Purchases from 'react-native-purchases';

const SubscriptionContext = createContext();

export const SubscriptionProvider = ({ children }) => {
  const [isPremium, setIsPremium] = useState(false);
  const [customerInfo, setCustomerInfo] = useState(null);

  useEffect(() => {
    const checkSubscriptionStatus = async () => {
      try {
        const customerInfo = await Purchases.getCustomerInfo();
        setCustomerInfo(customerInfo);
        setIsPremium(customerInfo.entitlements.active['premium'] !== undefined);
      } catch (error) {
        console.error('Error checking subscription status:', error);
      }
    };

    checkSubscriptionStatus();

    // Listen for subscription updates
    const listener = Purchases.addCustomerInfoUpdateListener(checkSubscriptionStatus);
    return () => listener.remove();
  }, []);

  return (
    <SubscriptionContext.Provider value={{ isPremium, customerInfo }}>
      {children}
    </SubscriptionContext.Provider>
  );
};

export const useSubscription = () => useContext(SubscriptionContext);
```

## Fast Prototyping with RevenueCat

### Rapid Testing Setup

RevenueCat's sandbox environment allows immediate testing without app store approval:

1. **Configure test products**: Set up offerings in RevenueCat dashboard
2. **Sandbox testing**: Test purchases using sandbox Apple/Google accounts
3. **Real-time updates**: Changes to offerings appear instantly in your app

### A/B Testing Subscriptions

Test different pricing strategies without app updates:

```javascript
// RevenueCat automatically serves different offerings based on your experiments
const offerings = await Purchases.getOfferings();

// Offering content changes based on active experiments
const currentOffering = offerings.current;
```

### Quick Revenue Validation

Launch subscription features within hours, not weeks:
- Configure products in RevenueCat dashboard
- Add minimal purchase UI to your app
- Start collecting real subscription data immediately

## Advantages of RevenueCat Integration

### 1. Platform Abstraction
- Single codebase handles iOS and Android subscriptions
- Automatic handling of platform-specific edge cases
- Consistent subscription state across platforms

### 2. Advanced Analytics
- Real-time revenue tracking and cohort analysis
- Customer journey visualization
- Integration with popular analytics tools (Amplitude, Mixpanel, etc.)

### 3. Server-Side Receipt Validation
- Automatic receipt validation prevents subscription fraud
- Real-time subscription status updates
- Webhook notifications for subscription events

### 4. Customer Support Tools
- Customer lookup and subscription management
- Refund and subscription modification capabilities
- Detailed transaction history

### 5. Easy A/B Testing
- Test different pricing without app releases
- Experiment with subscription tiers and trial periods
- Real-time experiment results

## Disadvantages to Consider

### 1. Third-Party Dependency
- Additional service dependency in your app architecture
- Potential service outages affecting subscription functionality
- Vendor lock-in considerations

### 2. Revenue Share
- RevenueCat charges a percentage of processed revenue
- Costs increase with subscription volume
- Additional fees on top of platform store fees

### 3. Learning Curve
- Initial setup requires understanding RevenueCat concepts
- Different mental model than direct platform integration
- Team training requirements

### 4. Limited Customization
- Restricted to RevenueCat's supported features
- Less control over low-level subscription handling
- Platform-specific features may not be available immediately

## Production Best Practices

### Error Handling Strategy

Implement comprehensive error handling for subscription flows:

```javascript
const handleSubscriptionError = (error) => {
  switch (error.code) {
    case 'PURCHASES_ERROR':
      // Network or server errors
      showRetryDialog();
      break;
    case 'USER_CANCELLED':
      // User cancelled purchase - no action needed
      break;
    case 'ITEM_UNAVAILABLE':
      // Product not available in user's region
      showRegionError();
      break;
    default:
      // Generic error handling
      showGenericError(error.message);
  }
};
```

### Subscription Restoration

Always provide subscription restoration for users switching devices:

```javascript
const restorePurchases = async () => {
  try {
    const customerInfo = await Purchases.restorePurchases();
    
    if (customerInfo.entitlements.active['premium']) {
      Alert.alert('Success', 'Your subscription has been restored!');
    } else {
      Alert.alert('No Subscriptions', 'No active subscriptions found.');
    }
  } catch (error) {
    Alert.alert('Restore Error', 'Failed to restore purchases.');
  }
};
```

### Offline Handling

Cache subscription status for offline scenarios:

```javascript
import AsyncStorage from '@react-native-async-storage/async-storage';

const cacheSubscriptionStatus = async (isPremium) => {
  await AsyncStorage.setItem('subscription_status', JSON.stringify(isPremium));
};

const getCachedSubscriptionStatus = async () => {
  const cached = await AsyncStorage.getItem('subscription_status');
  return cached ? JSON.parse(cached) : false;
};
```

## RevenueCat Across All Our Apps

We've successfully implemented RevenueCat in every mobile app we've developed, including:

- **Fitness tracking apps**: Premium workout plans and advanced analytics
- **Language learning apps**: Unlimited lessons and offline content
- **Productivity apps**: Advanced features and cloud sync
- **Entertainment apps**: Ad-free experience and exclusive content

The consistency of implementation across projects has significantly reduced development time and maintenance overhead.

## Results and ROI

Our experience with RevenueCat has delivered:

- **50% faster** subscription feature development
- **30% reduction** in subscription-related bugs
- **Real-time insights** into subscription performance
- **Simplified maintenance** across multiple apps
- **Better conversion rates** through A/B testing capabilities

## Conclusion

RevenueCat transforms subscription management from a complex, platform-specific challenge into a streamlined, data-driven process. While there are costs and dependencies to consider, the development speed, analytics capabilities, and maintenance benefits make it our preferred solution for React Native subscription implementations.

The ability to rapidly prototype, test, and iterate on subscription models has been particularly valuable for validating new app concepts and optimizing existing revenue streams.

**Ready to implement subscriptions in your React Native app?** Check out our [mobile app development services](/contact) or explore our [portfolio](/portfolio) to see RevenueCat in action across our client projects.

Following the successful launch of our Telegram bot Calories Tracker AI, we're now developing a mobile app for iOS and Android with enhanced UI/UX and advanced LLM integration.

From Telegram Bot to Mobile App: Expanding Calories Tracker AI to iOS and Android

---
title: "From Telegram Bot to Mobile App: Expanding Calories Tracker AI to iOS and Android"
date: "2025-08-01"
description: "Following the successful launch of our Telegram bot Calories Tracker AI, we're now developing a mobile app for iOS and Android with enhanced UI/UX and advanced LLM integration."
slug: "calories-tracker-mobile-app-development"
tags: "#mobileapp #calorietracker #ai #llm #reactnative #ios #android #healthtech"
---

# From Telegram Bot to Mobile App: Expanding Calories Tracker AI to iOS and Android

After the successful run of our **Calories Tracker AI** Telegram bot, we're excited to announce that we're expanding into the mobile app space! The positive user feedback and growing demand have motivated us to create a full-featured mobile application for both iOS and Android platforms.

## Why Make the Jump to Mobile?

Our Telegram bot proved that there's a real need for AI-powered calorie tracking that understands natural language. Users love being able to simply type "had a burger and fries for lunch" instead of manually searching through food databases. However, we realized that a dedicated mobile app could offer so much more:

### 📱 Enhanced User Experience
- **Native mobile interface** designed specifically for calorie tracking
- **Faster, more intuitive interactions** compared to chat-based interface
- **Visual food logging** with camera integration
- **Offline functionality** for tracking without internet connection

### 🤖 Advanced AI Integration
- **Improved LLM processing** with more sophisticated food recognition
- **Personalized recommendations** based on user patterns
- **Smart meal planning** suggestions
- **Nutritional insights** powered by advanced analytics

### 📊 Comprehensive Features
- **Detailed progress tracking** with charts and analytics
- **Goal setting and monitoring** for weight management
- **Recipe suggestions** based on dietary preferences
- **Integration with fitness apps** and wearables

## Current Development Status

We're currently in the **prototype phase** with exciting progress on multiple fronts:

### ✅ What's Ready
- **Core architecture** and database design completed
- **Basic food logging functionality** implemented
- **LLM integration** for natural language food parsing
- **User authentication** and profile management
- **Cross-platform foundation** using React Native

### 🚧 In Progress
- **UI/UX design finalization** - creating an intuitive, beautiful interface
- **Advanced LLM features** - enhancing food recognition accuracy
- **Camera integration** - for visual food logging
- **Data visualization** - comprehensive charts and progress tracking
- **Performance optimization** - ensuring smooth user experience

### 🔄 Next Steps
- **Beta testing** with selected users from our Telegram bot community
- **App Store optimization** and compliance preparation
- **Final polishing** of features and user interface
- **Launch preparation** for both iOS and Android platforms

## What Makes Our Approach Different

Building on the success of our Telegram bot, we're bringing several unique advantages to the mobile calorie tracking space:

### 🧠 Smart AI Understanding
Our LLM integration goes beyond simple keyword matching. Users can describe their meals naturally:
- "Had some pasta with marinara sauce and a side salad"
- "Grabbed a coffee and croissant this morning"
- "Homemade stir fry with chicken and vegetables"

### 🎯 User-Centric Design
Based on feedback from thousands of Telegram bot users, we're designing features that people actually want and use, not just what sounds good on paper.

### ⚡ Performance First
Unlike many calorie tracking apps that become slow and bloated, we're prioritizing speed and responsiveness from day one.

## The Technology Stack

We're leveraging modern technologies to deliver the best possible experience:

- **React Native** for cross-platform development
- **Advanced LLM models** for food recognition and parsing
- **Cloud infrastructure** for reliable data sync
- **Native integrations** with iOS and Android health platforms
- **Optimized offline functionality** for use anywhere

## What's Coming Next

We're targeting a **launch in Q4 2025** with the following timeline:

1. **August 2025**: Complete UI/UX finalization and LLM integration
2. **September 2025**: Begin beta testing with selected users
3. **October 2025**: App Store submission and review process
4. **November 2025**: Public launch on both iOS and Android

## Join the Journey

We're incredibly excited about this expansion from our successful Telegram bot to a full mobile experience. The combination of proven AI technology with native mobile capabilities will create something truly special for health-conscious users.

Stay tuned for updates on our development progress, beta testing opportunities, and launch announcements. The future of AI-powered calorie tracking is almost here!

#HealthTech #CalorieTracking #MobileAppDevelopment #AI #ReactNative #iOS #Android #LLM #HealthAndFitness #StartupJourney

New update for Catalan Verbs mobile app brings more training exercises, improved search functionality, and bug fixes for better learning experience.

Catalan Verbs App Update 1.2.1: Enhanced Learning Experience

---
title: "Catalan Verbs App Update 1.2.1: Enhanced Learning Experience"
date: "2025-07-31"
description: "New update for Catalan Verbs mobile app brings more training exercises, improved search functionality, and bug fixes for better learning experience."
slug: "catalan-verbs-app-update-1-2-1"
tags: "#mobileapp #reactnative #catalanverbs #appupdate #languagelearning"
---

# Catalan Verbs App Update 1.2.1: Enhanced Learning Experience

We're excited to announce the latest update for the Catalan Verbs mobile app! Version 1.2.1 is now available on both Android and iOS, bringing significant improvements to your language learning journey.

## What's New in Version 1.2.1

### 📚 More Training & Lessons
- Added new training exercises to help reinforce verb conjugation patterns
- Expanded lesson content for better progressive learning
- Enhanced practice modes for different skill levels

### 🔍 Improved Search
- Faster and more accurate verb search functionality
- Better filtering options to find exactly what you need
- Enhanced autocomplete suggestions

### 🐛 Bug Fixes & Performance
- Fixed rendering artifacts that affected the visual experience
- Resolved display issues on various device sizes
- General performance optimizations for smoother navigation

### ⚡ Technical Improvements
- Upgraded to the latest Expo framework for better stability
- Enhanced app performance and loading times
- Improved compatibility across different devices

## Download the Update

Update now to get the best Catalan learning experience:
- 📱 **iOS**: [App Store](https://apps.apple.com/es/app/catalan-verbs/id6738144158)
- 🤖 **Android**: [Google Play](https://play.google.com/store/apps/details?id=co.bitscorp.cat)

Continue mastering Catalan verb conjugations with these new improvements!

#CatalanLanguage #LanguageLearning #MobileAppUpdate #ReactNative #Education

Discover our streamlined MVP development services that take clients from initial concept to market-ready products. Learn about our proven process for custom software development consulting.

From Requirements to Revenue: Our Complete MVP Development Process

---
title: "From Requirements to Revenue: Our Complete MVP Development Process"
date: "2025-07-30"
description: "Discover our streamlined MVP development services that take clients from initial concept to market-ready products. Learn about our proven process for custom software development consulting."
slug: "mvp-development-client-journey"
tags: "#mvp #softwaredevelopment #consulting #mobile #ai #customsoftware"
---

# From Requirements to Revenue: Our Complete MVP Development Process

At Bitscorp, we've refined our **MVP development services** to deliver custom software solutions that get clients to market fast. Our **custom software development consulting** approach combines proven methodologies with cutting-edge AI tools to accelerate your journey from concept to revenue.

## The Complete Client Journey: 6 Phases to Success

### Phase 1: Discovery & Requirements Gathering (Week 1)

**Initial Consultation Call**: We start with a comprehensive discovery session to understand your vision, target market, and business objectives. This isn't just a feature list—we dive deep into your competitive landscape and user personas.

**Requirements Documentation**: Our **software consulting services** include creating detailed technical specifications that serve as the project blueprint. We document:
- Core user flows and interactions
- Technical architecture requirements
- Integration needs with existing systems
- Performance and scalability expectations

**Scope Definition**: We work with you to identify the true MVP scope—features that are essential for market validation versus nice-to-have additions that can wait for future iterations.

### Phase 2: Technical Architecture & Planning (Week 1-2)

**Technology Stack Selection**: Based on your requirements, we recommend the optimal technology stack. Whether it's **React Native development** for cross-platform mobile apps, **Python AI development** for machine learning features, or **cloud software solutions** for scalable backend services.

**Development Roadmap**: We create detailed project milestones with weekly progress checkpoints. This transparency ensures you're always informed about development progress and can provide feedback at critical decision points.

**Team Assignment**: Your project gets assigned to specialists based on complexity:
- **Mobile app development** experts for iOS and Android applications
- **AI development consulting** team for machine learning integration
- **Enterprise software development** architects for complex business logic

### Phase 3: Rapid MVP Development (Weeks 2-4)

**Agile Development Sprints**: We follow **agile software development** practices with weekly sprint reviews. Each sprint delivers working features you can test and provide feedback on.

**AI-Accelerated Development**: Our development process leverages AI tools for rapid prototyping and code generation, significantly reducing development time while maintaining code quality.

**Real-time Progress Updates**: Weekly demo calls showcase new features, gather feedback, and adjust priorities based on your evolving understanding of user needs.

**Key Development Areas**:
- **API development and integration** for seamless data flow
- **Mobile app UI/UX design** optimized for user engagement
- **Cloud-native app development** for reliability and scale
- **Software maintenance and support** planning from day one

### Phase 4: Testing & Quality Assurance (Week 4-5)

**Comprehensive Testing**: Our QA process includes automated testing, manual testing across devices, and performance optimization to ensure your MVP meets production standards.

**Security Review**: All applications undergo security auditing to protect user data and ensure compliance with industry standards.

**Performance Optimization**: We optimize loading times, database queries, and user interface responsiveness before launch.

### Phase 5: DevOps & Deployment (Week 5-6)

**Infrastructure Setup**: We handle complete **DevOps consulting services** including:
- Cloud infrastructure provisioning
- CI/CD pipeline configuration
- Monitoring and alerting systems
- Backup and disaster recovery

**App Store Deployment**: For mobile applications, we manage the entire app store submission process:
- **iOS and Android app development company** expertise for store guidelines
- App store optimization for better visibility
- Review process management and approval support

**Production Launch**: We coordinate the go-live process, monitor initial user traffic, and provide immediate support for any issues that arise.

### Phase 6: Post-Launch Support & Iteration (Ongoing)

**Performance Monitoring**: Real-time monitoring of application performance, user engagement metrics, and system health ensures optimal user experience.

**User Feedback Integration**: We help you collect and analyze user feedback to prioritize future feature development based on actual usage patterns.

**Iterative Enhancement**: Based on user data and feedback, we provide recommendations for feature additions, performance improvements, and scaling strategies.

## Specialized Service Areas

### Fintech & Financial Services

Our **fintech app development** expertise includes payment processing, regulatory compliance, and secure transaction handling. We've built solutions for digital banking, investment tracking, and cryptocurrency platforms.

### Healthcare Technology

**Healthcare software development** requires specialized knowledge of HIPAA compliance, patient data security, and clinical workflow optimization. Our team has experience with telemedicine platforms, patient management systems, and medical device integration.

### E-commerce Solutions

**E-commerce mobile apps** demand seamless payment integration, inventory management, and personalized user experiences. We build scalable platforms that grow with your business.

### Enterprise Solutions

**Enterprise software development** focuses on workflow automation, data integration, and scalability. Our solutions integrate with existing business systems while providing modern user experiences.

## Technology Leadership

### AI & Machine Learning Integration

**AI-powered mobile app development** and **machine learning software consulting** help businesses leverage data for competitive advantage. We integrate:
- Predictive analytics for user behavior
- Natural language processing for customer support
- Computer vision for automated content processing
- Recommendation engines for personalized experiences

### Modern Development Practices

**Cross-platform mobile app development services** using React Native and Flutter reduce development time while maintaining native performance. Our **microservices architecture** approach ensures applications scale efficiently as user bases grow.

### Cloud & Infrastructure

**Cloud software solutions** provide the foundation for scalable applications. We specialize in:
- AWS, Azure, and Google Cloud deployments
- Serverless architecture for cost optimization
- Auto-scaling for traffic spikes
- Multi-region deployments for global applications

## Why Choose Our MVP Development Approach

**Speed to Market**: Our streamlined process gets your MVP to users 60% faster than traditional development approaches, enabling quicker market validation and user feedback collection.

**Cost Efficiency**: By focusing on essential features first, we minimize initial development costs while building a foundation that supports future growth.

**Quality Assurance**: Despite rapid development, we never compromise on code quality, security, or user experience standards.

**Full-Service Support**: From initial concept to ongoing maintenance, we provide comprehensive **software development services** that support your entire product lifecycle.

**Proven Track Record**: Our portfolio includes successful MVPs across industries, from mobile games reaching 100K+ downloads to enterprise platforms serving millions of transactions.

## Success Metrics & Outcomes

Our **MVP development services** consistently deliver measurable results:
- 95% of MVPs launch within the agreed timeline
- Average 40% reduction in development costs compared to traditional approaches
- 85% client retention rate for post-launch development phases
- 92% first-attempt app store approval rate

## Getting Started

Ready to transform your idea into a market-ready product? Our **custom software development consulting** process begins with a free consultation to assess your project scope and recommend the optimal development approach.

**Contact us today** to discuss your MVP requirements and learn how our proven development process can accelerate your path to market success. Whether you need **mobile app development**, **AI integration consulting services**, or **enterprise software solutions**, our team has the expertise to deliver results that drive your business forward.

*Discover more about our development capabilities in our [portfolio](/portfolio) or explore our [pricing](/pricing) options to find the perfect fit for your project needs.*

Discover how Claude Code's sub-agent system transforms development workflows with specialized AI assistants. Learn practical techniques with a React Native recipe book app example.

Mastering Claude Code Sub-Agents: Advanced Development Workflows with Specialized AI Assistants

---
title: "Mastering Claude Code Sub-Agents: Advanced Development Workflows with Specialized AI Assistants"
description: "Discover how Claude Code's sub-agent system transforms development workflows with specialized AI assistants. Learn practical techniques with a React Native recipe book app example."
date: "2025-07-29"
author: "BitsCorp Team"
tags: "claude-code ai-development react-native typescript developer-tools"
category: "AI Development"
featured: true
slug: "claude-code-agents-article"
image: "/images/claude-code-agents.png"
---

Claude Code's sub-agent system represents a revolutionary approach to AI-assisted development, allowing developers to delegate specialized tasks to focused AI assistants. Rather than handling everything through a single conversation, sub-agents provide expert-level assistance for specific domains while preserving your main workflow's context and focus.

In this comprehensive guide, we'll explore how sub-agents can transform your development process using a practical React Native recipe book application as our example.

## Understanding Sub-Agents

Sub-agents are specialized AI assistants within Claude Code, each designed with specific expertise and tools. They operate with their own context windows and can be configured with custom system prompts, making them ideal for complex, multi-step workflows that require domain-specific knowledge.

### Key Benefits

- **Specialized Expertise**: Each sub-agent focuses on a specific domain (code review, debugging, data analysis)
- **Context Preservation**: Main conversation remains focused while sub-agents handle specialized tasks
- **Dynamic Task Delegation**: Claude Code can automatically select appropriate sub-agents based on context
- **Scalable Workflows**: Chain multiple sub-agents for complex development processes

## Common Sub-Agent Types

### 1. Code Reviewer
Expert in code quality, security, and best practices
- Analyzes code for readability and maintainability
- Identifies security vulnerabilities
- Suggests performance optimizations
- Validates test coverage

### 2. Debugger
Specialized in error analysis and problem resolution
- Performs root cause analysis
- Identifies patterns in error logs
- Suggests systematic debugging approaches
- Provides fix recommendations

### 3. Data Scientist
Expert in data analysis and database operations
- Writes efficient SQL queries
- Analyzes data patterns and trends
- Creates data visualizations
- Provides statistical insights

## Practical Example: Building a Mobile Recipe Book App

Let's explore how sub-agents can streamline the development of a React Native recipe book application.

### Project Setup with Architecture Review

```bash
# Initial project structure
/recipe-book-app
├── src/
│   ├── components/
│   ├── screens/
│   ├── services/
│   └── utils/
├── __tests__/
└── package.json
```

**Sub-agent delegation**: "Review this React Native project structure for a recipe book app and suggest improvements for scalability."

The **Architecture Reviewer** sub-agent might suggest:
- Adding a `hooks/` directory for custom React hooks
- Creating a `types/` directory for TypeScript definitions
- Implementing a `store/` directory for state management
- Adding `constants/` for app-wide configuration

### Feature Development Workflow

#### 1. Recipe Data Model Design

```typescript
// types/Recipe.ts
export interface Recipe {
  id: string;
  title: string;
  description: string;
  ingredients: Ingredient[];
  instructions: Instruction[];
  cookingTime: number;
  difficulty: 'easy' | 'medium' | 'hard';
  categories: string[];
  imageUrl?: string;
  nutritionInfo?: NutritionInfo;
}

export interface Ingredient {
  id: string;
  name: string;
  amount: number;
  unit: string;
}
```

**Sub-agent delegation**: "Review this recipe data model for completeness and suggest improvements."

The **Data Modeling** sub-agent might recommend:
- Adding validation schemas using Zod or Yup
- Including rating and review fields
- Adding preparation time separate from cooking time
- Implementing recipe versioning for updates

#### 2. Recipe List Component

```tsx
// components/RecipeList.tsx
import React from 'react';
import { FlatList, View, StyleSheet } from 'react-native';
import { Recipe } from '../types/Recipe';
import RecipeCard from './RecipeCard';

interface RecipeListProps {
  recipes: Recipe[];
  onRecipePress: (recipe: Recipe) => void;
}

export const RecipeList: React.FC<RecipeListProps> = ({
  recipes,
  onRecipePress,
}) => {
  const renderRecipe = ({ item }: { item: Recipe }) => (
    <RecipeCard 
      recipe={item} 
      onPress={() => onRecipePress(item)} 
    />
  );

  return (
    <FlatList
      data={recipes}
      renderItem={renderRecipe}
      keyExtractor={(item) => item.id}
      showsVerticalScrollIndicator={false}
      contentContainerStyle={styles.container}
    />
  );
};
```

**Sub-agent delegation**: "Review this React Native component for performance and accessibility."

The **React Native Specialist** sub-agent might suggest:
- Adding `getItemLayout` for better FlatList performance
- Implementing accessibility labels and hints
- Adding pull-to-refresh functionality
- Using `useMemo` for expensive calculations

#### 3. Recipe Search and Filtering

```typescript
// hooks/useRecipeSearch.ts
import { useState, useMemo } from 'react';
import { Recipe } from '../types/Recipe';

export const useRecipeSearch = (recipes: Recipe[]) => {
  const [searchQuery, setSearchQuery] = useState('');
  const [selectedCategories, setSelectedCategories] = useState<string[]>([]);
  const [difficultyFilter, setDifficultyFilter] = useState<string[]>([]);

  const filteredRecipes = useMemo(() => {
    return recipes.filter(recipe => {
      const matchesSearch = recipe.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
                           recipe.description.toLowerCase().includes(searchQuery.toLowerCase());
      
      const matchesCategory = selectedCategories.length === 0 ||
                             recipe.categories.some(cat => selectedCategories.includes(cat));
      
      const matchesDifficulty = difficultyFilter.length === 0 ||
                               difficultyFilter.includes(recipe.difficulty);

      return matchesSearch && matchesCategory && matchesDifficulty;
    });
  }, [recipes, searchQuery, selectedCategories, difficultyFilter]);

  return {
    searchQuery,
    setSearchQuery,
    selectedCategories,
    setSelectedCategories,
    difficultyFilter,
    setDifficultyFilter,
    filteredRecipes,
  };
};
```

**Sub-agent delegation**: "Optimize this search hook for better performance with large recipe datasets."

The **Performance Optimizer** sub-agent might recommend:
- Implementing debounced search to reduce filtering frequency
- Using `useCallback` for filter functions
- Adding search indexing for faster text matching
- Implementing virtual scrolling for large lists

### Advanced Sub-Agent Workflows

#### Multi-Agent Feature Development

For complex features like offline recipe storage, you might chain multiple sub-agents:

1. **Data Architect**: Design local storage schema
2. **React Native Expert**: Implement AsyncStorage integration
3. **Sync Specialist**: Create data synchronization logic
4. **Testing Expert**: Write comprehensive test coverage
5. **Performance Auditor**: Optimize for memory and battery usage

#### Custom Sub-Agent Configuration

```javascript
// .claude/agents/recipe-validator.md
# Recipe Validation Specialist

You are an expert in food data validation and nutrition standards.

## Responsibilities
- Validate recipe ingredient combinations
- Check nutritional information accuracy
- Ensure cooking time estimates are realistic
- Verify measurement unit conversions

## Tools Available
- Nutrition API access
- Cooking time calculation algorithms
- Ingredient compatibility database

## Output Format
Provide validation results with specific recommendations for improvements.
```

### Testing Strategy with Sub-Agents

```typescript
// __tests__/RecipeList.test.tsx
import React from 'react';
import { render, fireEvent } from '@testing-library/react-native';
import { RecipeList } from '../src/components/RecipeList';
import { mockRecipes } from './fixtures/recipes';

describe('RecipeList', () => {
  it('renders recipes correctly', () => {
    const onRecipePress = jest.fn();
    const { getByText } = render(
      <RecipeList recipes={mockRecipes} onRecipePress={onRecipePress} />
    );
    
    expect(getByText('Chocolate Chip Cookies')).toBeTruthy();
  });

  it('handles recipe press events', () => {
    const onRecipePress = jest.fn();
    const { getByTestId } = render(
      <RecipeList recipes={mockRecipes} onRecipePress={onRecipePress} />
    );
    
    fireEvent.press(getByTestId('recipe-card-0'));
    expect(onRecipePress).toHaveBeenCalledWith(mockRecipes[0]);
  });
});
```

**Sub-agent delegation**: "Review this test suite and suggest additional test cases for edge cases."

The **Testing Specialist** sub-agent might recommend:
- Testing empty recipe lists
- Verifying error states and loading indicators
- Adding accessibility testing
- Creating integration tests for user workflows

## Best Practices for Sub-Agent Usage

### 1. Clear Task Definition
Be specific about what you want the sub-agent to accomplish:
```
❌ "Review my code"
✅ "Review this React Native component for performance issues, accessibility compliance, and potential memory leaks"
```

### 2. Context Preservation
Provide relevant context to sub-agents:
```
"This recipe search component will handle up to 10,000 recipes and needs to work on older Android devices with limited memory."
```

### 3. Iterative Improvement
Use sub-agents for iterative refinement:
1. Initial implementation
2. Code review sub-agent feedback
3. Performance optimization sub-agent suggestions
4. Security audit sub-agent review

### 4. Domain-Specific Expertise
Leverage specialized knowledge:
- **Mobile UX Specialist**: For user interface improvements
- **Database Optimizer**: For efficient data queries
- **Security Auditor**: For vulnerability assessments
- **Accessibility Expert**: For inclusive design compliance

## Advanced Integration Patterns

### Automated Code Review Pipeline

```bash
# Triggered on code changes
1. Static Analysis Sub-agent
2. Security Scan Sub-agent
3. Performance Review Sub-agent
4. Documentation Update Sub-agent
```

### Feature Development Workflow

```bash
# New feature request
1. Requirements Analysis Sub-agent
2. Architecture Design Sub-agent
3. Implementation Planning Sub-agent
4. Code Generation Sub-agent
5. Testing Strategy Sub-agent
6. Documentation Sub-agent
```

## Conclusion

Claude Code's sub-agent system transforms development workflows by providing specialized, expert-level assistance for specific tasks. By understanding when and how to delegate to sub-agents, developers can maintain focus on high-level architecture and business logic while ensuring comprehensive coverage of technical details.

The recipe book app example demonstrates how sub-agents can enhance every aspect of development—from initial architecture design to performance optimization and testing. As you integrate sub-agents into your workflow, you'll discover new ways to leverage their specialized expertise for more efficient and higher-quality development outcomes.

Start experimenting with sub-agents in your next project, and experience the power of having a team of specialized AI assistants at your disposal.

---

*Want to learn more about AI-powered development tools? Check out our other articles on modern development workflows and subscribe to our newsletter for the latest updates in developer productivity.*


Learn how to generate stunning mobile app icons using Flux models in ComfyUI and polish them to perfection in Affinity Designer for professional results.

AI-Powered Mobile App Icon Generation: From Flux Models to Affinity Designer

Explore why Rust has become the go-to language for performance-critical services, covering popular packages and real-world use cases across major tech companies.

Why Rust is the Perfect Choice for Performance-Critical Services

---
title: "Why Rust is the Perfect Choice for Performance-Critical Services"
date: "2025-07-25"
description: "Explore why Rust has become the go-to language for performance-critical services, covering popular packages and real-world use cases across major tech companies."
slug: "rust-performance-advantages"
tags: "#rust #performance #systems #backend #tokio #serde #actix"
---

# Why Rust is the Perfect Choice for Performance-Critical Services

When performance matters most, choosing the right programming language can make or break your service. Rust has emerged as the champion for performance-critical applications, offering memory safety without garbage collection overhead and zero-cost abstractions that don't compromise speed.

## The Performance Advantage

### Memory Safety Without Performance Cost

Rust's ownership system eliminates entire classes of bugs that plague other systems languages like C and C++, while maintaining comparable performance. Unlike languages with garbage collectors (Java, Go, C#), Rust provides predictable performance characteristics crucial for latency-sensitive applications.

```rust
// Zero-cost abstraction example
fn process_data(items: Vec<Item>) -> Vec<ProcessedItem> {
    items.into_iter()
        .filter(|item| item.is_valid())
        .map(|item| item.process())
        .collect()
}
```

This code compiles to machine code as efficient as hand-optimized C, but with guaranteed memory safety.

## Essential Rust Packages for Performance

### Tokio - Asynchronous Runtime

**Tokio** is Rust's premier async runtime, enabling high-concurrency applications with minimal overhead.

```rust
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    
    loop {
        let (socket, _) = listener.accept().await?;
        tokio::spawn(handle_connection(socket));
    }
}
```

### Serde - Serialization Powerhouse

**Serde** provides compile-time serialization with zero runtime overhead, crucial for API services.

### Actix-Web - High-Performance Web Framework

**Actix-Web** consistently ranks among the fastest web frameworks across all languages in TechEmpower benchmarks.

### Rayon - Data Parallelism

**Rayon** makes parallel processing trivial while maintaining safety guarantees.

```rust
use rayon::prelude::*;

let results: Vec<_> = large_dataset
    .par_iter()
    .map(|item| expensive_computation(item))
    .collect();
```

## Real-World Rust Success Stories

### Dropbox - Storage Infrastructure

Dropbox rewrote their file storage system in Rust, achieving:
- 10x reduction in memory usage
- Significant performance improvements
- Enhanced reliability and safety

### Discord - Message Processing

Discord uses Rust for their message processing pipeline, handling millions of concurrent users with superior performance compared to their previous Go implementation.

### Mozilla - Firefox Components

Mozilla has migrated critical Firefox components to Rust, including:
- CSS parsing engine (Stylo)
- Media stack components
- Network security components

### Cloudflare - Edge Computing

Cloudflare uses Rust extensively in their edge infrastructure, powering services that handle millions of requests per second globally.

### Microsoft - Azure Services

Microsoft has adopted Rust for various Azure components, particularly in security-critical and performance-sensitive areas.

## When to Choose Rust

Rust excels in scenarios where performance and safety are paramount:

- **High-throughput web services** - API gateways, microservices
- **Real-time systems** - Game servers, trading platforms
- **Infrastructure tools** - Databases, load balancers, proxies  
- **CLI tools** - Where startup time and resource usage matter
- **Network services** - Where latency and throughput are critical

## Getting Started

Begin with these foundational packages:

```toml
[dependencies]
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
actix-web = "4.0"
clap = "4.0"  # CLI argument parsing
anyhow = "1.0"  # Error handling
```

## Conclusion

Rust's unique combination of memory safety, zero-cost abstractions, and growing ecosystem makes it an ideal choice for performance-critical services. Major tech companies have already proven its value in production environments, from Dropbox's storage systems to Discord's real-time messaging infrastructure.

The language's steep learning curve pays dividends in runtime performance, memory efficiency, and system reliability—exactly what you need when performance truly matters.

Discover how Lovable.dev revolutionizes web app prototyping with AI-powered development, seamless Supabase integration, and smart agent systems for rapid iteration.

Lightning-Fast Prototyping with Lovable.dev: From Idea to Production

---
title: "Lightning-Fast Prototyping with Lovable.dev: From Idea to Production"
date: "2025-07-24"
description: "Discover how Lovable.dev revolutionizes web app prototyping with AI-powered development, seamless Supabase integration, and smart agent systems for rapid iteration."
slug: "lovable-dev-rapid-prototyping"
tags: "#lovable #prototyping #ai #react #nextjs #supabase #webdev #nocode"
---

# Lightning-Fast Prototyping with Lovable.dev: From Idea to Production

In the fast-paced world of software development, the ability to rapidly prototype and iterate is crucial. Lovable.dev has emerged as a game-changing platform that transforms how we approach web application development, offering an AI-powered solution that bridges the gap between concept and production-ready applications.

## The Lovable.dev Revolution

### Chat-Driven Development

Lovable.dev introduces a paradigm shift in how we build applications. Instead of starting with empty files and complex setup procedures, you simply describe your application in natural language. The platform's AI agent understands your requirements and generates a fully functional web application using modern technologies like React and Next.js.

```
"Create a task management app with user authentication, 
project boards, and real-time collaboration features"
```

Within minutes, you have a working prototype complete with UI components, routing, and basic functionality.

## The AI Agent System: Intelligence Behind the Magic

### Conversational Development

Lovable's AI agent system represents a significant advancement in automated development. The agents understand context, maintain project consistency, and can handle complex architectural decisions. They excel at:

- **Requirements interpretation**: Converting natural language descriptions into technical specifications
- **Code generation**: Producing clean, maintainable React/Next.js code following best practices
- **Architecture decisions**: Choosing appropriate patterns for state management, routing, and component structure
- **Iteration handling**: Understanding modification requests and implementing changes without breaking existing functionality

### Smart Context Awareness

The agent system maintains awareness of your entire project structure, ensuring that new features integrate seamlessly with existing code. This contextual understanding prevents common issues like:
- Conflicting component names
- Inconsistent styling patterns
- Broken import chains
- State management conflicts

## Seamless Supabase Integration

### Backend-as-a-Service Made Simple

One of Lovable.dev's standout features is its native Supabase integration. This combination provides:

**Instant Database Setup**: The AI agent can configure PostgreSQL databases, set up authentication, and create the necessary tables based on your data requirements.

**Real-time Features**: Supabase's real-time subscriptions work seamlessly with Lovable-generated React components, enabling live updates without additional configuration.

**Authentication Flow**: User registration, login, and session management are implemented automatically with secure best practices.

```javascript
// Generated authentication component
const { user, signIn, signOut } = useSupabase();

return (
  <div>
    {user ? (
      <UserDashboard user={user} onSignOut={signOut} />
    ) : (
      <LoginForm onSignIn={signIn} />
    )}
  </div>
);
```

### Data Management Excellence

The platform generates type-safe database interactions, reducing runtime errors and improving development experience:

- **Automatic TypeScript types** from database schema
- **Query optimization** for common patterns
- **Error handling** with user-friendly fallbacks
- **Caching strategies** for performance optimization

## Development Workflow: From Prototype to Production

### Phase 1: Rapid Prototyping

Start with a conversational description of your application. Lovable.dev's AI agents create:
- Project structure with proper file organization
- UI components with responsive design
- Basic functionality and routing
- Database schema and API endpoints

### Phase 2: Iterative Refinement

The platform excels at understanding modification requests:

```
"Add a dark mode toggle to the header"
"Implement email notifications for task assignments"
"Create a dashboard with analytics charts"
```

Each request is processed intelligently, with the AI maintaining code quality and consistency.

### Phase 3: Advanced Features

As your prototype evolves, Lovable.dev handles complex requirements:
- **Payment integration** with Stripe
- **File upload** with secure storage
- **API integrations** with third-party services
- **Performance optimizations** for production deployment

### Phase 4: Production Deployment

The platform provides multiple deployment options:
- **Vercel integration** for seamless Next.js hosting
- **Custom domains** for professional branding
- **Environment management** for staging and production
- **Performance monitoring** and analytics

## Collaborative Development

### Team-Friendly Features

Lovable.dev supports modern development practices:

**Role-Based Access**: Different team members can have varying levels of access, from view-only to full editing permissions.

**Real-time Collaboration**: Multiple developers can work on the same project simultaneously, with changes synchronized instantly.

**Version Control**: Built-in versioning prevents conflicts and allows rollback to previous states.

**GitHub Integration**: Export your project to GitHub for traditional version control workflows when needed.

## Use Cases and Success Stories

### Internal Tools

Perfect for creating admin dashboards, employee portals, and workflow management systems with minimal development overhead.

### MVP Development

Startup teams can validate ideas quickly without extensive technical resources, focusing on user feedback rather than infrastructure setup.

### Client Prototypes

Agencies can demonstrate concepts to clients with functional prototypes instead of static mockups, improving communication and approval processes.

### Personal Projects

Individual developers can bring side project ideas to life without getting bogged down in boilerplate setup and configuration.

## Pricing Strategy for Different Needs

### Free Tier: Perfect for Experimentation
- 5 daily credits for testing the platform
- Public projects for portfolio building
- Up to 20 collaborators for small teams

### Pro Plan: Professional Development
- Extended credits for active development
- Private projects for confidential work
- Custom domains for client presentations
- Remove Lovable branding for professional appearance

### Enterprise: Scale and Security
- Custom integrations for existing workflows
- SSO for corporate security requirements
- Dedicated support for mission-critical projects
- Data privacy controls for sensitive applications

## Best Practices for Lovable.dev Success

### Effective Prompting

- **Be specific**: Detailed requirements produce better results
- **Iterate gradually**: Make incremental changes rather than major overhauls
- **Provide context**: Reference existing features when requesting modifications

### Quality Assurance

- **Test thoroughly**: Validate functionality across different devices and browsers
- **Review generated code**: Understand the implementation for future maintenance
- **Plan data structure**: Well-designed database schemas improve overall application quality

## The Future of Rapid Development

Lovable.dev represents the evolution of web development, where AI agents handle repetitive tasks while developers focus on creative problem-solving and user experience design. The platform's combination of intelligent code generation, seamless integrations, and collaborative features creates an environment where ideas can be validated and refined at unprecedented speed.

The integration with Supabase eliminates backend complexity, while the AI agent system ensures that generated code follows modern best practices. This combination makes Lovable.dev an ideal choice for teams who want to move fast without sacrificing code quality or scalability.

Whether you're building internal tools, client prototypes, or your next big idea, Lovable.dev provides the foundation for rapid iteration and successful deployment. The platform bridges the gap between concept and reality, making professional web application development accessible to teams of all sizes.

**Ready to accelerate your development process?** Explore our [portfolio](/portfolio) to see examples of rapid prototyping in action, or [contact us](/contact) to discuss how we can help bring your web application ideas to life using cutting-edge AI-powered development tools.

Complete guide to implementing internationalization in React Native apps using i18n, JSON locales, and AI-powered translation with Claude Code.

React Native Localization Made Easy with i18n and Claude Code

---
title: "React Native Localization Made Easy with i18n and Claude Code"
date: "2025-07-24"
description: "Complete guide to implementing internationalization in React Native apps using i18n, JSON locales, and AI-powered translation with Claude Code."
slug: "react-native-localization-i18n"
tags: "#reactnative #i18n #localization #claudecode #mobile #internationalization"
---

# React Native Localization Made Easy with i18n and Claude Code

Expanding your React Native app to global markets requires proper internationalization (i18n). Here's our streamlined approach using i18n, structured locale files, and AI-powered translation for rapid multi-language deployment.

## Setting Up the Foundation

### Installation & Configuration

First, install the necessary i18n packages:

```bash
npm install react-i18next i18next react-native-localize
```

Initialize i18n in your app's entry point:

```javascript
import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';
import * as RNLocalize from 'react-native-localize';

import en from './assets/locales/en.json';
import es from './assets/locales/es.json';
import fr from './assets/locales/fr.json';

const resources = {
  en: { translation: en },
  es: { translation: es },
  fr: { translation: fr },
};

i18n
  .use(initReactI18next)
  .init({
    resources,
    lng: RNLocalize.getLocales()[0].languageCode,
    fallbackLng: 'en',
    interpolation: {
      escapeValue: false,
    },
  });

export default i18n;
```

## Structuring Locale Files

### JSON Organization Strategy

We organize translations in `assets/locales/` with structured JSON files:

```json
// assets/locales/en.json
{
  "navigation": {
    "home": "Home",
    "profile": "Profile",
    "settings": "Settings"
  },
  "common": {
    "save": "Save",
    "cancel": "Cancel",
    "loading": "Loading..."
  },
  "auth": {
    "login": "Sign In",
    "register": "Create Account",
    "forgot_password": "Forgot Password?"
  },
  "errors": {
    "network": "Network connection failed",
    "validation": "Please check your input"
  }
}
```

This nested structure keeps translations organized and maintainable as your app grows.

## Implementation in Components

### Using the useTranslation Hook

The `useTranslation` hook provides seamless access to localized strings:

```javascript
import React from 'react';
import { View, Text, TouchableOpacity } from 'react-native';
import { useTranslation } from 'react-i18next';

const LoginScreen = () => {
  const { t } = useTranslation();

  return (
    <View>
      <Text>{t('auth.login')}</Text>
      <TouchableOpacity>
        <Text>{t('common.save')}</Text>
      </TouchableOpacity>
      <Text>{t('auth.forgot_password')}</Text>
    </View>
  );
};
```

### Dynamic Content with Interpolation

Handle dynamic values seamlessly:

```javascript
// Locale file
{
  "welcome": "Welcome back, {{name}}!",
  "items_count": "You have {{count}} items"
}

// Component usage
const WelcomeScreen = ({ userName, itemCount }) => {
  const { t } = useTranslation();

  return (
    <View>
      <Text>{t('welcome', { name: userName })}</Text>
      <Text>{t('items_count', { count: itemCount })}</Text>
    </View>
  );
};
```

## Language Switching

### Runtime Language Changes

Implement language switching with automatic UI updates:

```javascript
import React from 'react';
import { View, TouchableOpacity, Text } from 'react-native';
import { useTranslation } from 'react-i18next';

const LanguageSelector = () => {
  const { i18n, t } = useTranslation();

  const changeLanguage = (lng) => {
    i18n.changeLanguage(lng);
  };

  return (
    <View>
      <TouchableOpacity onPress={() => changeLanguage('en')}>
        <Text>English</Text>
      </TouchableOpacity>
      <TouchableOpacity onPress={() => changeLanguage('es')}>
        <Text>Español</Text>
      </TouchableOpacity>
      <TouchableOpacity onPress={() => changeLanguage('fr')}>
        <Text>Français</Text>
      </TouchableOpacity>
    </View>
  );
};
```

## AI-Powered Translation with Claude Code

### The Game-Changer: Automated Translation

Once you have your base English locale file ready, Claude Code transforms the translation process:

1. **Prepare your base locale**: Ensure `assets/locales/en.json` is complete and well-structured

2. **Use Claude Code for translation**: Simply ask:
   ```
   Please translate my en.json locale file to Spanish, French, German, Italian, Portuguese, Japanese, Korean, Chinese (Simplified), and Arabic. Maintain the JSON structure and keep interpolation variables unchanged.
   ```

3. **Instant multi-language support**: Claude Code generates all locale files in minutes, maintaining:
   - JSON structure integrity
   - Interpolation variable preservation
   - Cultural context awareness
   - Technical terminology accuracy

### Quality Assurance

Claude Code's translations consider:
- **Context preservation**: Technical terms remain consistent
- **UI constraints**: Translations fit mobile interface layouts
- **Cultural adaptation**: Messages feel natural to native speakers
- **Variable safety**: Interpolation syntax stays intact

## Production Deployment

### Build Optimization

Configure Metro bundler to include locale files:

```javascript
// metro.config.js
module.exports = {
  resolver: {
    assetExts: ['json', 'png', 'jpg', 'jpeg', 'gif'],
  },
  transformer: {
    assetPlugins: ['react-native-asset-plugin'],
  },
};
```

### App Store Localization

Prepare localized app store metadata:
- App names and descriptions
- Screenshot captions  
- Keyword optimization per market
- Privacy policy translations

## Best Practices

### Performance Optimization

- **Lazy loading**: Load only active language resources
- **Namespace splitting**: Separate translations by feature/screen
- **Caching**: Store user language preference locally

### Maintenance Strategy

- **Centralized updates**: Maintain English as the source of truth
- **Version control**: Track translation changes with meaningful commits
- **Testing**: Verify layouts across different text lengths

## Results

This approach enables:
- **Rapid deployment**: From single language to 10+ languages in hours
- **Consistent quality**: AI maintains translation standards across languages
- **Easy maintenance**: Single source file updates propagate efficiently
- **Cost effectiveness**: Eliminate manual translation overhead

The combination of structured i18n implementation and Claude Code's translation capabilities transforms localization from a complex, time-consuming process into a streamlined workflow that scales with your global ambitions.

Ready to expand your React Native app globally? Start with a solid i18n foundation, then let Claude Code handle the heavy lifting of multi-language translation. 

**Interested in building a globally-ready mobile app?** Check out our [portfolio](/portfolio) to see our localized applications in action, or [contact us](/contact) to discuss your international expansion project.

Master the key metrics and strategies for analyzing mobile game and app performance. Learn DAU, MAU, retention tactics, gamification, and proven techniques to boost user engagement.

Mobile Game & App Data Analysis: Essential Metrics and Retention Strategies

---
title: "Mobile Game & App Data Analysis: Essential Metrics and Retention Strategies"
date: "2025-07-23"
description: "Master the key metrics and strategies for analyzing mobile game and app performance. Learn DAU, MAU, retention tactics, gamification, and proven techniques to boost user engagement."
slug: "mobile-game-app-data-analysis-best-practices"
tags: "#mobileanalytics #gameanalytics #dataanalytics #userretention #gamification #mobileapps"
author: "Bitscorp"
---

# Mobile Game & App Data Analysis: Essential Metrics and Retention Strategies

In the competitive landscape of mobile games and applications, data-driven decision making isn't just advantageous—it's essential for survival. Understanding your users' behavior, engagement patterns, and retention metrics can mean the difference between a thriving app and one that fades into obscurity.

This comprehensive guide explores the fundamental metrics every mobile game and app developer should track, along with proven strategies to improve user retention and engagement.

## Core Engagement Metrics: The Foundation of Success

### Daily Active Users (DAU)
Daily Active Users represent the number of unique users who engage with your app within a 24-hour period. This metric serves as the pulse of your application's health.

**Why DAU Matters:**
- Immediate feedback on feature releases or updates
- Early warning system for engagement issues
- Foundation for calculating other critical metrics like retention rates

**Best Practices:**
- Define "active" clearly (app open, specific action, minimum session time)
- Track DAU trends over time, not just absolute numbers
- Segment DAU by user acquisition source to identify quality channels

### Weekly Active Users (WAU) and Monthly Active Users (MAU)
WAU and MAU provide broader perspectives on user engagement, smoothing out daily fluctuations and revealing longer-term trends.

**Key Insights:**
- **WAU** helps identify weekly usage patterns and the impact of weekend vs. weekday engagement
- **MAU** reveals monthly retention and seasonal trends
- The ratio of DAU/MAU indicates user engagement intensity (higher ratios suggest more frequent usage)

**Optimization Tips:**
- Aim for a DAU/MAU ratio of 20% or higher for engaged user bases
- Use WAU to plan weekly events or content releases
- Monitor MAU growth rate as a key business health indicator

## Retention Analysis: The Make-or-Break Metric

Retention is arguably the most critical metric for mobile apps and games. It's far more cost-effective to retain existing users than acquire new ones.

### Day 1, Day 7, and Day 30 Retention
- **Day 1 Retention:** Percentage of users who return the day after first install
- **Day 7 Retention:** Users who return within the first week
- **Day 30 Retention:** Long-term retention indicating product-market fit

**Industry Benchmarks:**
- **Mobile Games:** Day 1: 25-30%, Day 7: 10-15%, Day 30: 3-5%
- **Utility Apps:** Day 1: 20-25%, Day 7: 15-20%, Day 30: 8-12%
- **Social Apps:** Day 1: 30-35%, Day 7: 15-25%, Day 30: 8-15%

### Cohort Analysis
Track user groups based on their install date to understand how retention evolves over time and identify the impact of product changes.

**Implementation Strategy:**
- Create weekly or monthly cohorts
- Compare retention curves between different user acquisition channels
- Analyze the impact of onboarding changes on retention curves

## Advanced Metrics for Deeper Insights

### Session Length and Frequency
Understanding how long users spend in your app and how often they return provides insights into engagement quality.

**Key Metrics:**
- Average session duration
- Sessions per user per day
- Time between sessions

### Lifetime Value (LTV) and Revenue Metrics
For monetized apps, tracking revenue metrics alongside engagement data provides a complete picture of user value.

**Essential Revenue Metrics:**
- Average Revenue Per User (ARPU)
- Average Revenue Per Paying User (ARPPU)
- Conversion rate to paying user
- Customer Lifetime Value (CLV)

### Churn Analysis
Identify when and why users stop using your app to implement targeted retention strategies.

**Churn Indicators:**
- Decreasing session frequency
- Shorter session durations
- Lack of engagement with key features
- Time since last meaningful action

## Proven Retention Strategies

### 1. Gamification: Making Engagement Rewarding

Gamification leverages psychological principles to make mundane activities engaging and rewarding.

**Effective Gamification Elements:**
- **Progress Bars:** Visual representation of advancement toward goals
- **Achievement Systems:** Badges and milestones that recognize user accomplishments
- **Leaderboards:** Social competition that drives continued engagement
- **Streaks:** Daily activity chains that create habit formation
- **Level Systems:** Clear progression paths with meaningful rewards

**Implementation Best Practices:**
- Ensure rewards are meaningful and aligned with user goals
- Create multiple progression paths for different user types
- Balance challenge and achievability to avoid frustration
- Use variable reward schedules to maintain engagement

### 2. Daily Bonuses and Reward Systems

Strategic reward distribution can significantly impact user retention and create habitual usage patterns.

**Daily Bonus Strategies:**
- **Escalating Rewards:** Increasing value for consecutive days
- **Weekly Cycles:** Special rewards for completing full weeks
- **Comeback Bonuses:** Special incentives for returning users
- **Milestone Rewards:** Significant bonuses at key intervals (7, 30, 100 days)

**Best Practices:**
- Front-load early rewards to establish habits
- Use push notifications to remind users of unclaimed bonuses
- Create FOMO (fear of missing out) with time-limited offers
- Provide multiple ways to earn rewards beyond just daily logins

### 3. Strategic Push Notifications

Well-crafted push notifications can re-engage dormant users and maintain active user engagement.

**Notification Categories:**
- **Re-engagement:** Bring back users who haven't opened the app recently
- **Achievement:** Celebrate user milestones and accomplishments
- **Social:** Updates about friends' activities or competitive elements
- **Content:** New features, events, or content available
- **Personalized:** Based on individual user behavior and preferences

**Optimization Techniques:**
- A/B test notification copy, timing, and frequency
- Personalize messages based on user behavior and preferences
- Respect user preferences and local time zones
- Use rich notifications with images and interactive elements
- Implement smart timing based on when users are most likely to engage

## Widget Strategies: Learning from Duolingo

Duolingo's home screen widget strategy exemplifies how to maintain app presence and encourage daily engagement.

### Home Screen Widget Best Practices

**Widget Functionality:**
- **Progress Visualization:** Show streaks, daily goals, or completion status
- **Quick Actions:** Enable core actions directly from the widget
- **Motivational Content:** Display achievements, quotes, or progress celebrations
- **Smart Reminders:** Contextual prompts based on user behavior

**Design Principles:**
- Keep widgets simple and focused on core value proposition
- Update content dynamically to maintain relevance
- Use clear, readable fonts and high-contrast colors
- Optimize for different widget sizes and orientations

**Implementation Strategy:**
- Start with a simple progress/streak widget
- Gradually add functionality based on user feedback
- A/B test different widget designs and content
- Monitor widget usage analytics to optimize engagement

## Advanced Retention Techniques

### Personalization and AI-Driven Engagement

**Personalized Experiences:**
- Adaptive difficulty based on skill level
- Customized content recommendations
- Personalized notification timing and content
- Dynamic user interface adaptation

**Machine Learning Applications:**
- Predict user churn risk for proactive intervention
- Optimize push notification timing and content
- Personalize in-app recommendations
- Dynamic pricing and offer optimization

### Community and Social Features

**Social Engagement Elements:**
- Friend systems and social connections
- Guild or team-based activities
- User-generated content sharing
- Social challenges and competitions

**Community Building:**
- Forums or chat systems
- User events and tournaments
- Beta testing communities
- Influencer and creator programs

### Onboarding Optimization

**First-Time User Experience:**
- Progressive disclosure of features
- Interactive tutorials that demonstrate value
- Personalized setup based on user preferences
- Quick wins to establish early success

**Onboarding Metrics to Track:**
- Tutorial completion rates
- Time to first meaningful action
- Feature adoption during onboarding
- Correlation between onboarding completion and retention

## Measuring Success: KPIs and Dashboards

### Essential Dashboard Components

**Real-Time Metrics:**
- Current DAU/MAU numbers
- Real-time user sessions
- Push notification open rates
- Revenue metrics (for monetized apps)

**Trend Analysis:**
- Weekly and monthly retention cohorts
- User acquisition funnel performance
- Feature adoption rates over time
- Customer satisfaction scores (if applicable)

**Predictive Analytics:**
- Churn risk scoring
- LTV predictions
- User segmentation for targeted campaigns
- A/B test performance tracking

### Setting Up Effective Analytics

**Tool Selection:**
- **Firebase Analytics** for comprehensive mobile app analytics
- **Amplitude** for advanced user behavior analysis
- **Mixpanel** for detailed event tracking and funnels
- **AppsFlyer** for attribution and marketing analytics

**Event Tracking Strategy:**
- Define core events that indicate engagement
- Track user actions throughout the app journey
- Implement proper event naming conventions
- Ensure data quality through regular audits

## Future-Proofing Your Analytics Strategy

### Privacy-First Analytics

With increasing privacy regulations and platform changes:
- Implement first-party data collection strategies
- Focus on aggregated insights rather than individual tracking
- Ensure GDPR and CCPA compliance
- Build user trust through transparent data practices

### Emerging Technologies

**AI and Machine Learning:**
- Automated anomaly detection in user behavior
- Predictive analytics for user lifetime value
- Dynamic personalization engines
- Intelligent notification optimization

**Cross-Platform Analytics:**
- Unified user tracking across devices
- Cross-platform retention analysis
- Omnichannel user experience optimization

## Taking Action: Implementation Roadmap

### Phase 1: Foundation (Weeks 1-4)
1. Implement core metrics tracking (DAU, MAU, retention)
2. Set up basic cohort analysis
3. Establish baseline measurements
4. Create initial dashboard and reporting

### Phase 2: Optimization (Weeks 5-12)
1. Implement gamification elements
2. Launch daily bonus system
3. Optimize push notification strategy
4. A/B test key features and messaging

### Phase 3: Advanced Analytics (Weeks 13-24)
1. Deploy predictive churn models
2. Implement advanced personalization
3. Launch community features
4. Optimize user acquisition based on LTV data

## Partner with Data Experts

Building a comprehensive data analytics infrastructure for mobile games and apps requires specialized expertise in data engineering, analytics implementation, and strategic optimization.

**Our Data Pipeline and Analytics Services:**

At Bitscorp, we specialize in setting up robust data pipelines and comprehensive analytics solutions for mobile games and applications. Our team of data engineers and analysts can help you:

- **Custom Analytics Implementation:** Tailored tracking solutions that capture the metrics most critical to your app's success
- **Data Pipeline Architecture:** Scalable, real-time data processing systems that grow with your user base
- **Advanced User Segmentation:** Sophisticated audience analysis to optimize retention and monetization strategies
- **Predictive Analytics Models:** Machine learning solutions for churn prediction, LTV forecasting, and personalization
- **Dashboard and Reporting Systems:** Beautiful, actionable dashboards that provide insights at a glance
- **A/B Testing Infrastructure:** Statistical rigor in testing and optimization to maximize your retention improvements

Whether you're launching a new mobile game, scaling an existing app, or looking to optimize your current analytics setup, our team brings the expertise to transform your data into actionable insights that drive user engagement and business growth.

**Ready to unlock the full potential of your mobile app's data?** Contact Bitscorp today to discuss how we can build a custom analytics solution that drives measurable improvements in user retention and engagement.

**Let's turn your data into your competitive advantage.**

Discover how Luigi makes data pipeline orchestration effortless with tree-like task dependencies, built-in extensions for Hive, S3, Spark, and robust Python examples for enterprise data workflows.

Luigi Data Pipelines: Simplifying Python Workflow Orchestration

---
title: "Luigi Data Pipelines: Simplifying Python Workflow Orchestration"
date: "2025-07-22"
description: "Discover how Luigi makes data pipeline orchestration effortless with tree-like task dependencies, built-in extensions for Hive, S3, Spark, and robust Python examples for enterprise data workflows."
slug: "luigi-data-pipelines-python-workflow-orchestration"
tags: "#luigi #python #datapipelines #etl #spark #hive #s3 #dataengineering"
---

# Luigi Data Pipelines: Simplifying Python Workflow Orchestration

At Bitscorp, we've implemented numerous data pipeline solutions for our enterprise clients, and Luigi has consistently proven to be one of the most reliable and intuitive workflow orchestration tools available. In this comprehensive guide, we'll explore why Luigi stands out, how to implement it effectively, and the powerful extensions that make it enterprise-ready.

## Why We Choose Luigi for Data Pipelines

Luigi, developed by Spotify, addresses the fundamental challenges of data workflow orchestration with an elegant, Python-native approach. Here's why it's become our go-to solution:

### 1. **Declarative Task Dependencies**
Luigi's tree-like task structure makes complex workflows intuitive to design and maintain. Dependencies are explicitly declared, making pipeline logic transparent and debuggable.

### 2. **Failure Recovery**
Built-in failure handling and task retry mechanisms ensure robust data processing even in unstable environments.

### 3. **Incremental Processing**
Luigi's task completion tracking prevents unnecessary recomputation, making it ideal for large-scale data processing.

### 4. **Rich Ecosystem**
Extensive library of extensions for popular data platforms like Hadoop, Spark, AWS S3, and more.

## Core Luigi Concepts: requires(), run(), and output()

Every Luigi task follows a simple contract with three key methods:

### Basic Task Structure

```python
import luigi
import pandas as pd
from datetime import datetime, date

class ExtractCustomerData(luigi.Task):
    """Extract customer data from source database"""
    
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """Define task dependencies - what must complete before this task"""
        return []  # No dependencies for this initial extraction
    
    def output(self):
        """Define task output - how Luigi tracks completion"""
        return luigi.LocalTarget(f'data/customers_{self.date_param}.csv')
    
    def run(self):
        """The actual task logic"""
        # Simulate database extraction
        customers_data = {
            'customer_id': range(1, 1001),
            'name': [f'Customer_{i}' for i in range(1, 1001)],
            'signup_date': [self.date_param] * 1000,
            'lifetime_value': [100 + (i * 10) % 500 for i in range(1, 1001)]
        }
        
        df = pd.DataFrame(customers_data)
        
        # Write to output target
        with self.output().open('w') as output_file:
            df.to_csv(output_file, index=False)
```

## Building Complex Pipeline Trees

Luigi's strength lies in creating interconnected task dependencies. Here's a real-world example of a customer analytics pipeline:

```python
class TransformCustomerData(luigi.Task):
    """Transform and clean customer data"""
    
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """This task depends on raw customer data"""
        return ExtractCustomerData(date_param=self.date_param)
    
    def output(self):
        return luigi.LocalTarget(f'data/transformed_customers_{self.date_param}.csv')
    
    def run(self):
        # Read input from dependency
        input_df = pd.read_csv(self.input().open('r'))
        
        # Apply transformations
        input_df['customer_tier'] = pd.cut(
            input_df['lifetime_value'], 
            bins=[0, 200, 500, float('inf')], 
            labels=['Bronze', 'Silver', 'Gold']
        )
        
        input_df['days_since_signup'] = (
            pd.to_datetime('today') - pd.to_datetime(input_df['signup_date'])
        ).dt.days
        
        # Write transformed data
        with self.output().open('w') as output_file:
            input_df.to_csv(output_file, index=False)

class GenerateCustomerReport(luigi.Task):
    """Generate final customer analytics report"""
    
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """Depends on transformed data"""
        return TransformCustomerData(date_param=self.date_param)
    
    def output(self):
        return luigi.LocalTarget(f'reports/customer_report_{self.date_param}.json')
    
    def run(self):
        # Read transformed data
        df = pd.read_csv(self.input().open('r'))
        
        # Generate analytics
        report = {
            'date': str(self.date_param),
            'total_customers': len(df),
            'tier_distribution': df['customer_tier'].value_counts().to_dict(),
            'average_lifetime_value': df['lifetime_value'].mean(),
            'avg_days_since_signup': df['days_since_signup'].mean()
        }
        
        # Write report
        with self.output().open('w') as output_file:
            import json
            json.dump(report, output_file, indent=2)
```

## Advanced Pipeline Patterns

### Dynamic Task Generation

```python
class ProcessMultipleDataSources(luigi.Task):
    """Process data from multiple sources dynamically"""
    
    sources = luigi.ListParameter(default=['source_a', 'source_b', 'source_c'])
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """Generate tasks for each data source"""
        return [
            ProcessDataSource(source=source, date_param=self.date_param) 
            for source in self.sources
        ]
    
    def output(self):
        return luigi.LocalTarget(f'data/consolidated_{self.date_param}.csv')
    
    def run(self):
        # Combine all input files
        combined_data = []
        
        for input_target in self.input():
            df = pd.read_csv(input_target.open('r'))
            combined_data.append(df)
        
        final_df = pd.concat(combined_data, ignore_index=True)
        
        with self.output().open('w') as output_file:
            final_df.to_csv(output_file, index=False)

class ProcessDataSource(luigi.Task):
    """Process individual data source"""
    
    source = luigi.Parameter()
    date_param = luigi.DateParameter()
    
    def output(self):
        return luigi.LocalTarget(f'data/{self.source}_{self.date_param}.csv')
    
    def run(self):
        # Simulate source-specific processing
        data = {
            'source': [self.source] * 100,
            'value': range(100),
            'processed_date': [self.date_param] * 100
        }
        
        df = pd.DataFrame(data)
        
        with self.output().open('w') as output_file:
            df.to_csv(output_file, index=False)
```

## Luigi Extensions: Enterprise-Ready Integrations

Luigi's ecosystem includes powerful extensions for enterprise data platforms:

### 1. **Luigi Spark Integration**

```python
import luigi
from luigi.contrib.spark import SparkSubmitTask, PySparkTask

class SparkDataProcessing(PySparkTask):
    """Run Spark job for large-scale data processing"""
    
    date = luigi.DateParameter()
    
    def requires(self):
        return ExtractCustomerData(date_param=self.date)
    
    def output(self):
        return luigi.LocalTarget(f'spark_output/processed_{self.date}')
    
    def main(self, sc, *args):
        """PySpark job logic"""
        # Read input data
        input_rdd = sc.textFile(self.input().path)
        
        # Process with Spark
        processed_rdd = input_rdd.map(lambda line: line.upper())
        
        # Save results
        processed_rdd.saveAsTextFile(self.output().path)
```

### 2. **AWS S3 Integration**

```python
from luigi.contrib.s3 import S3Target, S3Task
import boto3

class UploadToS3(luigi.Task):
    """Upload processed data to S3"""
    
    date_param = luigi.DateParameter()
    bucket = luigi.Parameter(default='my-data-bucket')
    
    def requires(self):
        return GenerateCustomerReport(date_param=self.date_param)
    
    def output(self):
        return S3Target(f's3://{self.bucket}/reports/customer_report_{self.date_param}.json')
    
    def run(self):
        # Read local file and upload to S3
        with self.input().open('r') as input_file:
            with self.output().open('w') as s3_file:
                s3_file.write(input_file.read())

class S3DataExtraction(S3Task):
    """Extract data directly from S3"""
    
    date_param = luigi.DateParameter()
    source_bucket = luigi.Parameter(default='source-data-bucket')
    
    def output(self):
        return S3Target(f's3://{self.source_bucket}/raw_data_{self.date_param}.csv')
    
    def run(self):
        # S3-specific data extraction logic
        pass
```

### 3. **Hadoop Hive Integration**

```python
from luigi.contrib.hive import HiveQueryTask, HiveTableTarget

class HiveDataAggregation(HiveQueryTask):
    """Run Hive queries for data aggregation"""
    
    date_param = luigi.DateParameter()
    
    def query(self):
        return f"""
        INSERT OVERWRITE TABLE customer_summary_${{{self.date_param}}}
        SELECT 
            customer_tier,
            COUNT(*) as customer_count,
            AVG(lifetime_value) as avg_ltv,
            MIN(signup_date) as earliest_signup,
            MAX(signup_date) as latest_signup
        FROM customers 
        WHERE date_partition = '{self.date_param}'
        GROUP BY customer_tier
        """
    
    def output(self):
        return HiveTableTarget(
            table=f'customer_summary_{self.date_param}',
            database='analytics'
        )
```

### 4. **PostgreSQL Integration**

```python
from luigi.contrib.postgres import PostgresQuery, CopyToTable
import pandas as pd

class LoadCustomersToPostgres(CopyToTable):
    """Load processed customer data to PostgreSQL"""
    
    date_param = luigi.DateParameter()
    
    host = luigi.Parameter(default='localhost')
    database = luigi.Parameter(default='analytics')
    user = luigi.Parameter(default='luigi_user')
    password = luigi.Parameter(default='password')
    table = luigi.Parameter(default='customer_analytics')
    
    def requires(self):
        return TransformCustomerData(date_param=self.date_param)
    
    def columns(self):
        return [
            ('customer_id', 'INT'),
            ('name', 'VARCHAR(255)'),
            ('signup_date', 'DATE'),
            ('lifetime_value', 'DECIMAL(10,2)'),
            ('customer_tier', 'VARCHAR(50)'),
            ('days_since_signup', 'INT')
        ]
    
    def rows(self):
        """Read data and yield rows for insertion"""
        df = pd.read_csv(self.input().open('r'))
        
        for _, row in df.iterrows():
            yield (
                row['customer_id'],
                row['name'],
                row['signup_date'],
                row['lifetime_value'],
                row['customer_tier'],
                row['days_since_signup']
            )
```

## Running Luigi Pipelines

### Command Line Execution

```bash
# Run a specific task
python -m luigi --module customer_pipeline GenerateCustomerReport --date-param 2025-07-22

# Run with Luigi scheduler daemon
luigid  # Start scheduler in background

# Run with web UI
python -m luigi --module customer_pipeline GenerateCustomerReport --date-param 2025-07-22 --scheduler-host localhost
```

### Configuration File (luigi.cfg)

```ini
[core]
logging_conf_file = logging.conf
no_configure_logging = True

[task_history]
db_connection = sqlite:///luigi_history.db

[postgres]
host = localhost
database = analytics
user = luigi_user
password = secure_password

[spark]
spark_home = /opt/spark
master = local[*]
deploy_mode = client
```

## Monitoring and Web Interface

Luigi provides an excellent web interface for monitoring pipeline execution:

```python
# Start Luigi central scheduler with web UI
# Visit http://localhost:8082 to see:
# - Task dependency graphs
# - Execution status
# - Error logs
# - Resource utilization
# - Historical runs
```

## Best Practices We Follow at Bitscorp

### 1. **Idempotent Tasks**
```python
class IdempotentDataProcessing(luigi.Task):
    def run(self):
        # Always write to a temp file first
        temp_output = luigi.LocalTarget(self.output().path + '.tmp')
        
        with temp_output.open('w') as f:
            # Do processing
            pass
        
        # Atomic move to final location
        temp_output.move(self.output())
```

### 2. **Parameter Validation**
```python
class ValidatedTask(luigi.Task):
    start_date = luigi.DateParameter()
    end_date = luigi.DateParameter()
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        if self.start_date >= self.end_date:
            raise ValueError("start_date must be before end_date")
```

### 3. **Resource Management**
```python
class ResourceManagedTask(luigi.Task):
    def requires_resources(self):
        # Limit concurrent database connections
        return {'database_connections': 1}
    
    def run(self):
        # Task will wait for resource availability
        pass
```

## Advanced Luigi Extensions Available

Luigi's ecosystem extends far beyond basic functionality:

- **luigi-docker**: Run tasks in Docker containers
- **luigi-kubernetes**: Deploy Luigi tasks on Kubernetes
- **luigi-bigquery**: Google BigQuery integration
- **luigi-redshift**: Amazon Redshift support
- **luigi-salesforce**: Salesforce data extraction
- **luigi-elasticsearch**: Elasticsearch indexing
- **luigi-ftp**: FTP file operations
- **luigi-hdfs**: Hadoop Distributed File System support

## Conclusion

Luigi has proven invaluable in our data engineering projects at Bitscorp. Its Python-native approach, robust dependency management, and extensive ecosystem make it ideal for enterprise data pipelines. The clear separation of concerns through `requires()`, `run()`, and `output()` methods creates maintainable, testable workflows that scale with your data needs.

Whether you're building simple ETL processes or complex multi-stage analytics pipelines, Luigi provides the foundation for reliable, monitorable data workflows. Its integration with popular big data tools like Spark, Hive, and cloud platforms makes it a comprehensive solution for modern data engineering challenges.

For enterprises looking to implement robust data pipeline orchestration, Luigi offers the perfect balance of simplicity, power, and reliability that we've come to depend on in our client projects.

Learn how we revolutionized a hotel chain's customer service with an intelligent bot system using n8n workflows, OpenAI O3, and multi-platform integration across Telegram and WhatsApp.

Transforming Hotel Customer Service with AI: A Complete Bot Solution Using n8n and OpenAI

---
title: "Transforming Hotel Customer Service with AI: A Complete Bot Solution Using n8n and OpenAI"
date: "2025-07-11"
description: "Learn how we revolutionized a hotel chain's customer service with an intelligent bot system using n8n workflows, OpenAI O3, and multi-platform integration across Telegram and WhatsApp."
slug: "ai-hotel-bot-n8n-transformation"
tags: "#n8n #openai #hotel #telegram #whatsapp #automation #customerservice #ai"
---

# Transforming Hotel Customer Service with AI: A Complete Bot Solution Using n8n and OpenAI

The hospitality industry thrives on exceptional customer service, but providing 24/7 support while managing costs remains a persistent challenge. At Bitscorp, we recently transformed a boutique hotel chain's operations by developing an intelligent customer service bot that handles everything from room inquiries to emergency escalations—all while enhancing rather than replacing human interaction.

## The Challenge: Modern Hospitality Pain Points

Our client, a rapidly growing boutique hotel chain, faced the universal hospitality dilemma:

**Around-the-Clock Demands**: Guests expect instant responses regardless of time zones or staff availability.

**Repetitive Inquiries**: 70% of customer questions were about amenities, directions, policies, and booking procedures.

**Channel Fragmentation**: Customers contacted them via phone, email, social media, and messaging apps, creating inconsistent experiences.

**Staff Burnout**: Front desk employees spent most of their time answering the same questions instead of creating memorable guest experiences.

**Lost Revenue**: Delayed responses led to abandoned bookings and frustrated potential guests choosing competitors.

## The Solution: Intelligent Automation with Human Touch

We designed a comprehensive AI-powered customer service ecosystem that seamlessly blends automation with human expertise.

### Technical Architecture Overview

**Core Technologies**:
- **n8n**: Visual workflow orchestration for complex decision trees
- **OpenAI O3**: Cost-effective AI model for natural language understanding
- **Telegram & WhatsApp APIs**: Multi-platform customer engagement
- **Knowledge Base**: Comprehensive hotel information repository
- **Booking System Integration**: Direct connection to reservation platform

### Building the Knowledge Foundation

The bot's intelligence starts with a meticulously crafted knowledge base containing:

**Property Information**:
- Detailed room descriptions with amenities
- High-quality room photos for instant sharing
- Facility information (pool, gym, restaurant hours)
- Local attraction recommendations

**Operational Data**:
- Check-in/check-out procedures
- Pricing structures and special offers
- Pet policies and accessibility features
- Emergency protocols and contacts

**Location Intelligence**:
- Precise driving directions from major landmarks
- Public transportation options
- Nearby restaurants and attractions
- Parking information and costs

### n8n Workflow Orchestration: The Brain of Operations

n8n's visual workflow builder proved perfect for managing complex customer service logic. Here's how we structured the decision flow:

```javascript
// Core n8n workflow logic
function processCustomerQuery(message, customer_data) {
  // Step 1: Analyze intent and urgency
  const intent = analyzeIntent(message);
  const urgency = assessUrgency(message, customer_data);

  // Step 2: Route based on intent and urgency
  if (urgency === 'CRITICAL') {
    notifyManager(customer_data, message);
    escalateToHuman();
    return "Emergency escalation initiated";
  }

  if (intent === 'BOOKING') {
    return redirectToBookingSystem(customer_data);
  }

  if (intent === 'DIRECTIONS') {
    return sendLocationAndDirections(customer_data.location);
  }

  if (intent === 'ROOM_INFO') {
    return sendRoomPhotosAndDetails(intent.room_type);
  }

  // Default: AI-powered response
  return generateAIResponse(message, knowledgeBase);
}
```

### OpenAI O3: The Cost-Effective Intelligence Engine

We chose OpenAI's O3 model for its optimal balance of capability and cost-effectiveness:

**Natural Language Understanding**: Accurately interprets customer intent across multiple languages and communication styles.

**Context Awareness**: Maintains conversation context to provide relevant follow-up responses.

**Sentiment Analysis**: Detects frustrated or urgent customers for appropriate escalation.

**Knowledge Integration**: Seamlessly accesses and presents information from the hotel's knowledge base.

### Multi-Platform Integration: Meeting Customers Where They Are

**Telegram Integration**:
- Rich media support for room photos and location sharing
- Inline keyboard navigation for easy option selection
- Bot commands for quick access to common information

**WhatsApp Business Integration**:
- Familiar interface for international guests
- Voice message support for complex inquiries
- Status updates for booking confirmations

### Intelligent Decision Making

The bot's intelligence shines in its decision-making capabilities:

#### Escalation Logic
```javascript
function shouldEscalate(message, customerHistory) {
  const urgencyIndicators = [
    'emergency', 'urgent', 'complaint', 'problem',
    'broken', 'not working', 'unhappy', 'refund'
  ];

  const isUrgent = urgencyIndicators.some(word =>
    message.toLowerCase().includes(word)
  );

  const isRepeatCustomer = customerHistory.interactions > 3;
  const hasRecentComplaint = customerHistory.lastComplaint < 24; // hours

  return isUrgent || (isRepeatCustomer && hasRecentComplaint);
}
```

#### Booking Integration
```javascript
function handleBookingInquiry(customerData, dates, roomType) {
  // Check availability in real-time
  const availability = checkAvailability(dates, roomType);

  if (availability.hasRooms) {
    return {
      action: 'redirect_to_booking',
      message: generateBookingLink(customerData, dates, roomType),
      rooms: availability.rooms
    };
  } else {
    return {
      action: 'suggest_alternatives',
      alternatives: suggestAlternativeDates(dates, roomType)
    };
  }
}
```

## Real-World Implementation Stories

### Case Study 1: The Lost Guest

A guest messaged at 11 PM: "I'm lost trying to find your hotel. GPS isn't working properly."

**Bot Response**:
1. Instantly identified location-based intent
2. Sent precise driving directions with landmarks
3. Shared hotel location pin
4. Provided front desk direct contact for real-time assistance
5. Followed up 30 minutes later to ensure safe arrival

**Outcome**: Guest arrived safely and later praised the immediate, helpful response in their review.

### Case Study 2: The Emergency Escalation

A guest reported: "The air conditioning in room 302 isn't working and it's very hot."

**Bot Intelligence**:
1. Detected urgency keywords and room number
2. Immediately notified night manager via SMS
3. Escalated to human staff within 2 minutes
4. Logged the issue in maintenance system
5. Followed up next day to ensure resolution

**Outcome**: Maintenance resolved the issue within 15 minutes, preventing a negative review and demonstrating proactive service.

### Case Study 3: The International Booking

A Spanish-speaking guest inquired about weekend availability.

**Bot Capabilities**:
1. Detected Spanish language and responded accordingly
2. Checked real-time availability for requested dates
3. Showed room photos with Spanish descriptions
4. Provided direct booking link with pre-filled guest information
5. Offered local restaurant recommendations in Spanish

**Outcome**: Completed booking within 10 minutes, generating €450 in revenue from a previously unreachable market segment.

## Business Impact: Transformation by the Numbers

### Customer Experience Metrics

**Response Time**: Average response time decreased from 45 minutes to 3 seconds for standard inquiries.

**Customer Satisfaction**: CSAT scores increased from 7.2 to 9.1 out of 10.

**Resolution Rate**: 89% of customer inquiries resolved without human intervention.

**Multilingual Support**: Now serving customers in 12 languages automatically.

### Operational Efficiency

**Staff Productivity**: Front desk staff productivity increased 60%, focusing on high-value guest interactions.

**Cost Reduction**: Customer service costs reduced by 45% while improving service quality.

**24/7 Availability**: True round-the-clock service without additional staffing costs.

**Booking Conversion**: Direct booking rate increased 35% through seamless bot-to-booking integration.

### Revenue Impact

**Increased Bookings**: 28% increase in direct bookings through improved customer experience.

**Reduced Abandonment**: Booking abandonment rate decreased 52% due to instant query resolution.

**Upselling Opportunities**: Bot identifies and promotes relevant upgrades, increasing average booking value 15%.

## Technical Excellence: Why This Stack Works

### n8n Advantages

**Visual Development**: Complex workflows designed graphically, making modifications intuitive for non-technical staff.

**Integration Ecosystem**: Native connectors for major platforms eliminate custom API development.

**Scalability**: Easily handles peak seasons and sudden traffic spikes.

**Maintenance**: Visual workflows are easy to understand, modify, and troubleshoot.

### OpenAI O3 Benefits

**Cost Optimization**: Delivers sophisticated AI capabilities at a fraction of premium model costs.

**Multilingual Support**: Native language understanding across dozens of languages.

**Contextual Intelligence**: Maintains conversation flow and understands implied meanings.

**Rapid Deployment**: No model training required—instant deployment with prompt engineering.

### Multi-Platform Strategy

**Customer Choice**: Guests use their preferred communication platform.

**Unified Experience**: Consistent service quality across all channels.

**Rich Media**: Platform-specific features like photos, locations, and quick replies.

## Lessons Learned and Best Practices

### Knowledge Base Curation

**Regular Updates**: Monthly review and update of hotel information and local recommendations.

**Staff Input**: Front desk team contributes common questions and effective responses.

**Guest Feedback**: Customer interactions inform knowledge base improvements.

### Escalation Design

**Clear Triggers**: Well-defined criteria for human handoff prevent customer frustration.

**Context Preservation**: Complete conversation history transfers to human agents.

**Follow-up Automation**: Automated check-ins ensure issue resolution.

### Performance Monitoring

**Analytics Dashboard**: Real-time monitoring of bot performance and customer satisfaction.

**Continuous Learning**: Regular analysis of unresolved queries to improve bot capabilities.

**A/B Testing**: Systematic testing of response variations to optimize effectiveness.

## Future Enhancements

**Voice Integration**: Adding voice message processing for more natural interactions.

**Predictive Analytics**: Anticipating guest needs based on booking patterns and preferences.

**IoT Integration**: Connecting with room systems for real-time status updates.

**Personalization Engine**: Customized recommendations based on guest history and preferences.

## Getting Started: Implementation Roadmap

### Phase 1: Foundation (Week 1-2)
- Knowledge base creation and curation
- n8n workflow design and testing
- OpenAI integration and prompt optimization

### Phase 2: Platform Integration (Week 3-4)
- Telegram and WhatsApp bot deployment
- Booking system API integration
- Emergency notification setup

### Phase 3: Testing and Refinement (Week 5-6)
- Comprehensive testing with real scenarios
- Staff training on escalation procedures
- Fine-tuning based on initial feedback

### Phase 4: Launch and Optimization (Week 7+)
- Gradual rollout to guest interactions
- Performance monitoring and adjustments
- Continuous improvement based on analytics

## Conclusion: The Future of Hospitality Customer Service

This project demonstrates how thoughtful AI implementation can enhance rather than replace human service. By automating routine inquiries, our hotel bot frees staff to create memorable experiences while ensuring guests receive instant, accurate assistance around the clock.

The combination of n8n's workflow orchestration, OpenAI's cost-effective intelligence, and multi-platform integration creates a scalable solution that grows with the business. Most importantly, it improves both guest satisfaction and staff productivity—a rare win-win in technology implementation.

The hospitality industry's future lies not in choosing between human service and automation, but in intelligently combining both to create experiences that exceed guest expectations while optimizing operational efficiency.

*Ready to transform your customer service? Start with a comprehensive knowledge base, design intelligent workflows in n8n, and let AI handle the routine while your team focuses on creating unforgettable experiences.*

Discover how we automated stock market analysis using Claude AI for data gathering and DuckDB for lightning-fast analytics. Learn about our Python-powered pipeline for daily financial intelligence.

AI-Powered Stock Analysis with DuckDB and Claude: Automating Financial Data Intelligence

---
title: "AI-Powered Stock Analysis with DuckDB and Claude: Automating Financial Data Intelligence"
date: "2025-07-01"
description: "Discover how we automated stock market analysis using Claude AI for data gathering and DuckDB for lightning-fast analytics. Learn about our Python-powered pipeline for daily financial intelligence."
slug: "ai-powered-stock-analysis-duckdb"
tags: "#duckdb #claude #ai #stocks #python #analytics #automation"
---

# AI-Powered Stock Analysis with DuckDB and Claude: Automating Financial Data Intelligence

At Bitscorp, we've revolutionized our approach to financial data analysis by combining Claude AI's research capabilities with DuckDB's blazing-fast analytics engine. Our automated pipeline gathers, processes, and analyzes stock market data daily, providing actionable insights through an elegant Python-powered workflow.

## The Challenge: Information Overload in Financial Markets

Financial markets generate massive amounts of data every second. Traditional approaches to stock analysis often involve:
- Manual research across multiple sources
- Complex database setups for data storage
- Slow query performance on large datasets
- Time-intensive data preparation workflows

We needed a solution that could automate data gathering while providing lightning-fast analytics capabilities.

## Our Solution: Claude + DuckDB + Python

### Claude AI: The Research Powerhouse

Claude's research mode has proven exceptionally effective for gathering comprehensive stock information. Here's why Claude excels at financial data collection:

**Speed and Accuracy**: Claude processes multiple financial sources simultaneously, extracting relevant metrics, news sentiment, and fundamental analysis in seconds rather than hours.

**Structured Output**: We prompt Claude to format stock data directly into CSV format, eliminating manual data transformation steps.

**Research Mode Excellence**: Claude's research capabilities allow it to cross-reference multiple sources, providing comprehensive company analysis including financial ratios, recent news impact, and market sentiment.

**Real-time Insights**: Claude can analyze breaking news, earnings reports, and market movements as they happen, providing context that pure numerical data cannot capture.

### DuckDB: The Analytics Beast

DuckDB has become our go-to choice for financial data analytics, and here's why it's absolutely awesome:

**Single Binary Simplicity**: Installing DuckDB requires just one binary file—no complex database server setup, no configuration files, no administrative overhead. You download it, run it, and you're analyzing data.

**Blazing Performance**: DuckDB's columnar storage and vectorized execution engine make it incredibly fast for analytical queries. Complex aggregations across millions of stock records complete in milliseconds.

**SQL Compatibility**: Full PostgreSQL-compatible SQL syntax means our team can leverage existing SQL knowledge without learning new query languages.

**Python Integration**: Native Python integration allows seamless data flow from our Claude-powered collection scripts directly into analytics workflows.

**CSV Superpowers**: DuckDB can query CSV files directly without importing—perfect for our daily stock data files from Claude.

**Advanced Analytics**: Built-in support for window functions, complex aggregations, and statistical functions makes sophisticated financial analysis straightforward.

## The Automated Workflow

### Daily Data Collection

Our Python script orchestrates the entire pipeline:

```python
# Simplified workflow overview
def daily_stock_analysis():
    # 1. Claude gathers stock data
    stock_data = claude_research_stocks(watchlist)

    # 2. Save to CSV with timestamp
    save_to_csv(stock_data, f"stocks_{today}.csv")

    # 3. DuckDB analytics
    insights = analyze_with_duckdb(stock_data)

    # 4. Generate reports
    generate_daily_report(insights)
```

### Claude's Research Process

We've fine-tuned our prompts to make Claude an exceptional financial researcher:

1. **Multi-Source Analysis**: Claude examines financial statements, recent news, analyst reports, and market sentiment
2. **Structured Data Extraction**: Outputs consistent CSV format with standardized columns for price data, ratios, and qualitative assessments
3. **Contextual Intelligence**: Provides reasoning for stock movements and identifies potential catalysts

### DuckDB Analytics Magic

Once Claude delivers the CSV data, DuckDB takes over for analysis:

```sql
-- Example: Identify trending stocks with high momentum
SELECT
    symbol,
    company_name,
    price_change_percent,
    volume_ratio,
    sentiment_score,
    ROW_NUMBER() OVER (ORDER BY momentum_score DESC) as rank
FROM daily_stocks
WHERE date = '2025-01-20'
    AND momentum_score > 0.7
ORDER BY momentum_score DESC;
```

### Automation Benefits

**Zero Manual Intervention**: The entire pipeline runs automatically via cron jobs, collecting and analyzing data while we sleep.

**Consistent Data Quality**: Claude's structured prompts ensure consistent data format across all collection runs.

**Scalable Architecture**: Adding new stocks to our watchlist requires only updating a configuration file.

**Cost Effective**: No expensive Bloomberg terminals or premium data feeds—Claude accesses publicly available information intelligently.

## Why This Stack Works

### DuckDB Advantages for Financial Data

- **No Database Administration**: Focus on analysis, not database maintenance
- **Instant Deployment**: One binary file deployment across any environment
- **Memory Efficiency**: Handles large datasets efficiently on modest hardware
- **Export Flexibility**: Easy integration with visualization tools and reporting systems

### Claude's Financial Intelligence

- **Comprehensive Research**: Synthesizes information from multiple sources automatically
- **Natural Language Processing**: Understands financial jargon and market context
- **Rapid Information Processing**: Analyzes multiple stocks simultaneously
- **Adaptable Prompting**: Easily modify research focus based on market conditions

### Python Orchestration

- **Ecosystem Integration**: Seamless integration with both Claude API and DuckDB
- **Scheduling Flexibility**: Easy automation with cron jobs or task schedulers
- **Error Handling**: Robust retry mechanisms for API calls and data processing
- **Extensibility**: Simple to add new data sources or analysis methods

## Real-World Impact

Our automated system has transformed our investment research process:

- **Time Savings**: What previously took hours of manual research now completes in minutes
- **Data Consistency**: Standardized data collection eliminates human error
- **Comprehensive Coverage**: Monitor hundreds of stocks simultaneously
- **Actionable Insights**: DuckDB's fast queries enable real-time decision making

## Getting Started

The beauty of this stack lies in its simplicity:

1. **Install DuckDB**: Download one binary file
2. **Set up Claude API**: Simple API key configuration
3. **Write Python glue**: Basic scripts to orchestrate the workflow
4. **Start Analyzing**: Begin with a small watchlist and expand

This approach democratizes sophisticated financial analysis, making institutional-grade research capabilities accessible to individual investors and small teams.


*Ready to automate your financial research? Start with DuckDB's single binary, connect to Claude's research capabilities, and let Python orchestrate your path to data-driven investment decisions.*

Learn our proven workflow for rapid application development using Claude Code for prototyping, followed by Cursor for refinement. Case study: Brawl Stars gameplay streaming app.

Rapid App Prototyping with Claude Code: From Idea to Store-Ready

---
title: "Rapid App Prototyping with Claude Code: From Idea to Store-Ready"
date: "2025-06-24"
description: "Learn our proven workflow for rapid application development using Claude Code for prototyping, followed by Cursor for refinement. Case study: Brawl Stars gameplay streaming app."
slug: "rapid-prototyping-claude-code-workflow"
tags: "#claudecode #prototyping #ios #swift #ai #development"
---

# Rapid App Prototyping with Claude Code: From Idea to Store-Ready

At Bitscorp, we've revolutionized our development process by leveraging AI tools for rapid application prototyping. Our workflow combines Claude Code's intelligent code generation with Cursor's refinement capabilities to go from concept to store-ready applications in record time.

## Current Project: Brawl Stars Gameplay Streaming App

We're currently developing an iOS application for streaming Brawl Stars gameplay, set to launch in August 2025. This project perfectly demonstrates our streamlined AI-powered development workflow.

## The 5-Phase Development Workflow

### Phase 1: Foundation with Claude Code

**Project Initialization**: We start by asking Claude Code to create the entire Xcode project structure, including proper Swift configurations and iOS deployment settings.

**Architecture Planning**: The magic happens when we provide Claude Code with a detailed prompt describing our app concept. It generates a comprehensive base plan including:
- Core streaming functionality architecture
- UI component structure
- Data flow patterns
- Integration points for gameplay capture

**Swift Implementation**: Claude Code handles the heavy lifting of implementing core features, from camera integration to streaming protocols, generating clean, maintainable Swift code.

### Phase 2: Refinement with Cursor

**Code Polish**: We transition to Cursor for meticulous step-by-step refinement, ensuring every component meets production standards.

**Testing & Debugging**: Making the application fully runnable involves comprehensive testing, proper error handling, and performance optimization.

**iOS-Specific Optimizations**: Fine-tuning streaming performance, memory management, and ensuring smooth gameplay capture without affecting game performance.

### Phase 3: Visual Identity

**Competitive Analysis**: Before creating assets, we analyze competitor app icons to understand market expectations and design trends.

**AI-Powered Icon Generation**: We use ChatGPT for icon design, but the key is crafting detailed prompts that specify style, color schemes, and brand alignment. This requires careful prompt preparation to ensure consistent results across different icon sizes and platforms.

### Phase 4: Global Market Preparation

**Multi-Language Support**: Claude Code excels at translating app descriptions and metadata into 10+ languages, maintaining context and marketing appeal across cultures.

**Store Asset Organization**: We create separate folders containing optimized descriptions for App Store and Google Play, each tailored to platform-specific requirements and character limits.

**Screenshot Workflow**: Using iOS Simulator, we capture key app screens, then design compelling store screenshots in Figma that highlight core features and user benefits.

### Phase 5: Backend Integration

**Supabase Integration**: When backend services are required, we choose Supabase for its rapid deployment capabilities—providing both client SDKs and PostgreSQL database setup with minimal configuration.

**Real-time Features**: For streaming applications, Supabase's real-time subscriptions handle live data synchronization between viewers and streamers seamlessly.

## Why This Workflow Works

**Speed**: Traditional development cycles of months are compressed into weeks.

**Quality**: AI-generated code provides solid foundations that human refinement elevates to production quality.

**Cost-Effectiveness**: Reduced development time translates directly to lower costs and faster market entry.

**Scalability**: The workflow adapts to projects of any complexity, from simple utilities to feature-rich applications.

## Key Takeaways

1. **AI as Foundation Builder**: Claude Code excels at creating comprehensive project structures and implementing core functionality based on natural language descriptions.

2. **Human Refinement is Essential**: While AI provides excellent foundations, human expertise in Cursor ensures production-ready code quality.

3. **Asset Generation Strategy**: Success with AI-generated assets requires thoughtful prompt engineering and competitive analysis.

4. **Global-First Approach**: Planning for international markets from day one, rather than retrofitting localization, saves significant time and resources.

This workflow has transformed how we approach mobile development, enabling rapid iteration and faster time-to-market while maintaining high code quality standards. The combination of Claude Code's intelligent generation and human refinement creates a powerful development pipeline that scales with project complexity.

*Ready to streamline your development process? Start with a clear project description and let AI handle the foundation while you focus on the unique value your application brings to users.*

Discover my journey building a Catalan verb conjugation mobile app using React Native, Python, and web scraping. Learn about the tech stack and development process behind this educational language learning tool.

EdTech Innovation: Developing Cross-Platform Language Learning Solutions

---
title: "EdTech Innovation: Developing Cross-Platform Language Learning Solutions"
date: "2024-12-28"
description: "Discover my journey building a Catalan verb conjugation mobile app using React Native, Python, and web scraping. Learn about the tech stack and development process behind this educational language learning tool."
slug: "catalan-verbs-mobile-app-5abm"
tags: "#mobileapp #reactnative #indiedev"
---

# Catalan Verbs: My Birthday Gift to Language Learners

I'm thrilled to announce that I've just released a new mobile application to celebrate my birthday! As someone living near Barcelona, I've found myself increasingly drawn to the beautiful Catalan language. This fascination inspired me to create a tool that could help others on their language learning journey.

## Why Catalan?

Catalan is not only the official language of Catalonia but also a rich linguistic treasure with a fascinating history. Living close to Barcelona has given me the opportunity to immerse myself in this melodic language, and I wanted to share my passion with fellow language enthusiasts worldwide.

## The Development Journey

Creating this app was both a learning experience and a labor of love. I tackled one of the most challenging aspects of Catalan - verb conjugations - and turned it into an accessible mobile tool for learners of all levels.

### Tech Stack

- **React Native**: For cross-platform mobile development
- **Scrapy**: To gather comprehensive verb conjugation data
- **Python**: For automating translations and data processing
- **Cursor**: An AI-powered code editor that significantly accelerated my development workflow

The combination of these technologies allowed me to create a responsive, user-friendly application with accurate linguistic content.

## Features

The app provides:
- Comprehensive conjugation tables for Catalan verbs
- Search functionality to quickly find specific verbs
- Offline access to all content
- Clean, intuitive interface designed for learners
- Example sentences to understand usage in context

## Ready to Master Catalan Verbs?

Whether you're a beginner just starting your Catalan journey or an advanced learner polishing your skills, this app offers the perfect companion for mastering verb conjugations.

Download now:
- 📱 **iOS**: [App Store](https://apps.apple.com/es/app/catalan-verbs/id6738144158)
- 🤖 **Android**: [Google Play](https://play.google.com/store/apps/details?id=co.bitscorp.cat)

I welcome your feedback and suggestions for future updates!

#CatalanLanguage #LanguageLearning #Education #ReactNative #TechInEducation


Discover how to learn Spanish with a Chrome extension. Learn about the development process and the benefits of using a Chrome extension for learning Spanish.

Browser Extension Monetization: Building Educational Tools with Payment Integration

---
title: "Browser Extension Monetization: Building Educational Tools with Payment Integration"
date: "2024-09-08"
description: "Discover how to learn Spanish with a Chrome extension. Learn about the development process and the benefits of using a Chrome extension for learning Spanish."
slug: "learn-spanish-chrome-extension-b12"
tags: "#chrome #extension"
---

# Introducing My New Spanish Learning Chrome Extension

I'm excited to announce that I've just published a new Chrome extension designed to help you learn Spanish! I developed it quickly, but it has already become an invaluable tool in my own Spanish learning journey over the past few months.

## [Learn Spanish Chrome Extension](https://chromewebstore.google.com/detail/learn-spanish/onnolcnjhjbmcgfppkmamfkadklopbkj?ref=producthunt)

### Key Features:
- **Free Plan**: Learn 10 new Spanish words daily
- **Premium Option**: I've integrated Whop payment processing to offer a one-time lifetime payment that unlocks unlimited words with each new tab

While monetization wasn't my primary goal, I wanted to experiment with implementing a payment system in a Chrome extension as a learning experience.

If you're looking for a simple, effective way to gradually build your Spanish vocabulary, give it a try!

Thank you for reading!




Discover how to integrate OpenAI into your React Native application. Learn about the development process and the benefits of using OpenAI for your application.

Accelerating Mobile Innovation: Integrating OpenAI Intelligence into React Native Applications

---
title: "Accelerating Mobile Innovation: Integrating OpenAI Intelligence into React Native Applications"
date: "2024-06-10"
description: "Discover how to integrate OpenAI into your React Native application. Learn about the development process and the benefits of using OpenAI for your application."
slug: "react-native-and-openai-4e9a"
tags: "#reactnative #openai #mobileapp"
---

# Integrating OpenAI with React Native: A Fun Experiment

I recently developed a simple application using OpenAI/ChatGPT and was amazed by how enjoyable and straightforward the process was.

[Watch the app preview here](https://www.youtube.com/watch?v=4NjaXtJHTwM)

While the app is admittedly more of a novelty than a serious tool, I was particularly impressed by the ability to upload images and ask specific questions about them. This was my first experience with AI integration, and though it might seem obvious to developers already working with AI models, I found it fascinating.

Let's examine the core communication function to better understand how the app works:

```typescript
const sendMessage = async (image_url: string, language: AppLanguage) => {
  try {
    const openai = new OpenAI({
      apiKey: OPENAI_API_KEY, // This is the default and can be omitted
    });

    const { data: completion } = await openai.chat.completions
      .create({
        model: "gpt-4-turbo",
        stream: false,
        messages: [
          {
            role: "system",
            content: `
You are palm reader, explain by reading palm the user background, life, future, fate. Please write at least 10 setences about each topic:
- user line of life
- user line of heart
- user line of mind
- user line of fate
- user extra information that we need to mention

Only provide a RFC8259 compliant JSON response:
[
  {
    "line_life": "user line of life",
    "line_heart": "user line of heart",
    "line_mind": "user line of mind",
    "line_fate": "user line of fate",
    "line_extra": "user extra information"
  }
]`,
          },
          {
            role: "user",
            content: [
              {
                type: "text",
                text: `
- user line of life, 10+ sentences
- user line of heart, 10+ sentences
- user line of mind, 10+ sentences
- user line of fate, 10+ sentences
- user extra information that we need to mention, 10+ sentences
                `,
              },
              {
                type: "text",
                text: `Use language ${language} for answers.`,
              },
              {
                type: "text",
                text: 'Describe my palm but in format { "line_heart": "text...", "line_life": "text...", "line_mind": "text...", "line_fate": "text...", "line_extra": "text..." }',
              },
              {
                type: "image_url",
                image_url: {
                  url: `data:image/jpeg;base64,${image_url}`,
                },
              },
            ],
          },
        ],
      })
      .withResponse();

    const replies = completion.choices
      .flatMap((choice) => {
        try {
          if (choice.message.content === null || choice.message.content === undefined) {
            return [];
          } else {
            const messages = JSON.parse(choice.message.content);

            return messages;
          }
        } catch (error) {
          Sentry.Native.captureException(error);

          return [];
        }
      })
      .reduce((acc, cur) => ({ ...acc, ...cur }), {});

    return replies;
  } catch (error) {
    Sentry.Native.captureException(error);
  }
};
```

As you can see, I used specific prompts to format the responses in JSON and passed an image for analysis. I also localized the app by supporting English, Spanish, German, French, and Russian languages. Simply instructing ChatGPT to respond in a specific language worked perfectly out of the box—it's like mathematical magic!

I plan to publish the app, but there's a significant challenge: using `gpt-4-turbo` is quite expensive. The app will likely remain available for a while, but I may need to disable it eventually due to the costs involved.






Discover how we developed the mobile app using ReactNative / Supabase / ChatGPT and then published it to the App Store and Google Play.

Rapid Mobile Development: Two-Week App Store Success Story

---
title: "Rapid Mobile Development: Two-Week App Store Success Story"
date: "2023-10-01"
description: "Discover how we developed the mobile app using ReactNative / Supabase / ChatGPT and then published it to the App Store and Google Play."
slug: would-it-be-interesting-for-anyone-to-have-the-text-based-guide-on-how-we-develop-pushupbitscorpco-mobile-app-for-2-weeks-2bae
tags: #mobileapp #reactnative #supabase #chatgpt
---

I'm considering creating a text-based course that walks through how we developed our mobile app using React Native, Supabase, and ChatGPT, then successfully published it to both the App Store and Google Play.

In just one month, our app gained over 60 users through organic traffic alone (no paid advertising). It currently tracks between 20-40 daily sports activities from active users.

From my experience, fitness apps tend to receive more organic traffic on iOS compared to Android platforms.

Check out our app:
- [App Store](https://apps.apple.com/us/app/pushup-challenges/id6450053262)
- [Google Play](https://play.google.com/store/apps/details?id=co.bitscorp.pushup)
- [Web](https://pushup.bitscorp.co)



Discover how to build a mobile app to improve your daily habits. Learn about the development process and the benefits of using a mobile app for your daily habits.

Health Tech Development: Creating Habit-Building Fitness Applications

---
title: "Health Tech Development: Creating Habit-Building Fitness Applications"
date: "2023-09-11"
description: "Discover how to build a mobile app to improve your daily habits. Learn about the development process and the benefits of using a mobile app for your daily habits."
slug: "push-up-mobile-app-4lll"
tags: "#mobileapp #appstore #googleplay"
---

# Introducing Push Up: A Fitness Habit Builder

We're excited to share our pet project designed to improve health through daily habits!

## What is Push Up?

Push Up is a simple fitness app focused on two fundamental exercises: push-ups and squats. The concept is straightforward - invite friends and start building healthy exercise habits together.

This app evolved from a humble Google spreadsheet tracking system into a full-featured mobile application that makes fitness social and fun.

## Why We Created It

Many of us spend long hours at our desks, which can negatively impact our health. Push Up encourages short, effective exercise breaks throughout your workday to keep you energized and healthy.

## Try It Today!

Ready to transform your daily routine? Visit [Push Up](https://pushup.bitscorp.co/) and start your fitness journey today.

We hope this app helps you improve your lifestyle during your busy workday!





Learn how to optimize Elixir Phoenix actions with large JSON responses by implementing cached, gzipped values.

Optimizing Elixir Phoenix Actions with Huge JSON Responses Using Cached, Gzipped Values

---
title: "Optimizing Elixir Phoenix Actions with Huge JSON Responses Using Cached, Gzipped Values"
date: "2023-07-19"
description: "Learn how to optimize Elixir Phoenix actions with large JSON responses by implementing cached, gzipped values."
slug: "optimizing-elixir-phoenix-action-with-huge-json-response-by-responding-by-cached-gzipped-values-1d64"
tags: "#elixir #phoenix #phoenixframework"
---

Hello everyone,

I'm excited to be back and share some recent optimizations I've implemented for a client project. We've been developing a React Native mobile application that includes a wiki-like section providing users with step-by-step health improvement information.

## The Challenge

One significant challenge we faced was handling a massive JSON response—approximately 20MB in size—retrieved from a single endpoint during the app's loading process. While splitting API requests and loading content on-demand was an option, we also wanted to ensure offline accessibility for users. This made a one-time load during the initial launch beneficial, despite taking around 6 seconds depending on internet speed.

## The Solution

Looking for a quick optimization, particularly for the wiki endpoints, we found the perfect solution in the [cachex](https://github.com/whitfin/cachex) library. This impressive tool includes a `warmer` module that automatically refreshes cached data either on boot or after a specified `ttl` (time-to-live).

By integrating cachex into our system, we've significantly improved the loading process, providing users with a smoother experience while maintaining offline accessibility. Let me walk you through how we implemented this caching solution for our Phoenix Controller actions with large JSON responses.

```elixir
defmodule BlogApp.Cache.PostsWarmer do
  use Cachex.Warmer

  alias BlogApp.Posts

  require Logger
  require Jsonrs

  @cache_table :blog_app_cache
  @posts_cache_key {:posts, :list_posts}

  def interval, do: :timer.minutes(60)

  def execute(_args) do
    data = [
      get_posts()
    ]

    {:ok, data, [ttl: :timer.minutes(60)]}
  end

  def get_cached_posts() do
    get_or_put(@posts_cache_key)
  end

  defp get_posts() do
    posts = Posts.list_published_posts()

    posts =
      BlogAppWeb.Api.V1.PostsView.render("index.json", %{
        posts: posts
      })
      |> Jsonrs.encode!()
      |> :zlib.gzip()

    {@posts_cache_key, posts}
  end

  defp get_or_put(key) do
    case Cachex.get(@cache_table, key) do
      nil ->
        case key do
          @posts_cache_key ->
            {key, posts} = get_posts()

            Cachex.put(@cache_table, key, posts)
            Cachex.get(@cache_table, key)

          _ ->
            Logger.error("[your_app] cache key not found: #{inspect(key)}")

            nil
        end

      value ->
        value
    end
  end
end
```

## Implementation Steps

First, create a `cache.ex` file in the lib folder:

```elixir
defmodule BlogApp.Cache do
  @moduledoc """
  Cache
  """
  @cache_table :blog_app_cache

  import Cachex.Spec

  def child_spec(_init_arg) do
    %{
      id: @cache_table,
      type: :supervisor,
      start:
        {Cachex, :start_link,
         [
           @cache_table,
           [
             warmers: [
               warmer(module: BlogApp.Cache.PostsWarmer, state: "")
             ]
           ]
         ]}
    }
  end
end
```

Next, add the warmer module to your `application.ex`:

```elixir
defmodule BlogApp.Application do
  @moduledoc false

  use Application

  def start(_type, _args) do
    children = [
      # ... existing code ...
      {BlogApp.Cache, []}
    ]

    Supervisor.start_link(children, strategy: :one_for_one, name: BlogApp.Supervisor)
  end
end
```

Finally, integrate the cached, gzipped data in your Phoenix controller:

```elixir
def index(conn, _params) do
  {:ok, posts} = PostsWarmer.get_cached_posts()

  conn
  |> put_resp_header("Content-Encoding", "gzip")
  |> put_resp_content_type("application/json")
  |> send_resp(200, posts)
end
```

## Results

This simple implementation provides a powerful speed boost. For processing large JSON files, we've also started using [jsonrs](https://github.com/benhaney/Jsonrs), which further enhances performance.

The key benefits of this approach include:
- Significantly reduced response times
- Decreased server load
- Improved user experience
- Maintained offline functionality

Thank you for reading!

---

Available for consulting in Elixir, Go, JS, and Big Data.
Visit our website: [bitscorp.co](https://bitscorp.co)
Find me on GitHub: [github.com/oivoodoo](https://github.com/oivoodoo), [github.com/bitscorp](https://github.com/bitscorp)
My other blog: [https://dev.to/oivoodoo](https://dev.to/oivoodoo)

```elixir
defmodule BlogApp.Cache.PostsWarmer do
  use Cachex.Warmer

  alias BlogApp.Posts

  require Logger
  require Jsonrs

  @cache_table :blog_app_cache
  @posts_cache_key {:posts, :list_posts}

  def interval, do: :timer.minutes(60)

  def execute(_args) do
    data = [
      get_posts()
    ]

    {:ok, data, [ttl: :timer.minutes(60)]}
  end

  def get_cached_posts() do
    get_or_put(@posts_cache_key)
  end

  defp get_posts() do
    posts = Posts.list_published_posts()

    posts =
      BlogAppWeb.Api.V1.PostsView.render("index.json", %{
        posts: posts
      })
      |> Jsonrs.encode!()
      |> :zlib.gzip()

    {@posts_cache_key, posts}
  end

  defp get_or_put(key) do
    case Cachex.get(@cache_table, key) do
      nil ->
        case key do
          @posts_cache_key ->
            {key, posts} = get_posts()

            Cachex.put(@cache_table, key, posts)
            Cachex.get(@cache_table, key)

          _ ->
            Logger.error("[your_app] cache key not found: #{inspect(key)}")

            nil
        end

      value ->
        value
    end
  end
end

```elixir
defmodule BlogApp.Cache do
  @moduledoc """
  Cache
  """
  @cache_table :blog_app_cache

  import Cachex.Spec

  def child_spec(_init_arg) do
    %{
      id: @cache_table,
      type: :supervisor,
      start:
        {Cachex, :start_link,
         [
           @cache_table,
           [
             warmers: [
               warmer(module: BlogApp.Cache.PostsWarmer, state: "")
             ]
           ]
         ]}
    }
  end
end

```elixir
defmodule BlogApp.Application do
  @moduledoc false

  use Application

  def start(_type, _args) do
    children = [
      # ... existing code ...
      {BlogApp.Cache, []}
    ]

    Supervisor.start_link(children, strategy: :one_for_one, name: BlogApp.Supervisor)
  end
end

```elixir
def index(conn, _params) do
  {:ok, posts} = PostsWarmer.get_cached_posts()

  conn
  |> put_resp_header("Content-Encoding", "gzip")
  |> put_resp_content_type("application/json")
  |> send_resp(200, posts)
end


Discover how to sell your game arts and complete games with discounts via Gumroad. Learn about the development process and the benefits of using Gumroad for your ecommerce needs.

Digital Asset Monetization: Building Revenue Streams Through Game Asset Sales

---
title: "Digital Asset Monetization: Building Revenue Streams Through Game Asset Sales"
date: "2021-12-27"
description: "Discover how to sell your game arts and complete games with discounts via Gumroad. Learn about the development process and the benefits of using Gumroad for your ecommerce needs."
slug: "road-to-ecommerce-via-gumroad--20nh"
tags: "#gameart #gamedev #ecommerce #gumroad"
---

# Selling Game Assets and Complete Games on Gumroad

Hi everyone!

I've recently started selling my game art assets and complete Unity-based games on Gumroad. These resources could be valuable for other developers looking for ready-made assets or inspiration.

My current focus is on developing new games, with a tower defense style game coming next month to test audience interest. However, I need to raise some budget for marketing my upcoming game, and Gumroad seems like the perfect platform for this. I've been impressed by how easy it is to create product pages and start selling right away.

## Available Products

### Complete Games
- [Complete Game - Don't Fall](https://balconygames.gumroad.com/l/game-dont-fall/happycoding?_gl=1*2dery6*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDI5MjUuMA..)
  - Available on: [Google Play](https://play.google.com/store/apps/details?id=com.balconygames.dontfall) and [App Store](https://apps.apple.com/es/app/dont-fall-by-balcony-games/id1460842492)

### Game Art Assets
- [Game Art - Don't Fall (older version)](https://balconygames.gumroad.com/l/dont-fall-art/bsfr4ww?_gl=1*1k5lihx*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDI5OTQuMA..)

- [Game Art - Snake](https://balconygames.gumroad.com/l/snake-game-art/bsfr4ww?_gl=1*1jr3fd8*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDMwMTIuMA..)
  - See it in action: [Google Play](https://play.google.com/store/apps/details?id=com.balconygames.snake)

- [Game Art - Paint Swipe](https://balconygames.gumroad.com/l/paiint-swipe-game/bsfr4ww?_gl=1*o9b1hp*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDMwMzIuMA..) - This game is currently unfinished, but I plan to polish it and share the source code in the future.

I hope you find these resources useful for your projects!

Thank you,

Alex


Discover how to create a Phoenix umbrella proxy application. Learn about the development process and the benefits of using a proxy application for your Phoenix projects.

Phoenix umbrella proxy application.

---
title: "Phoenix umbrella proxy application."
date: "2021-06-15"
description: "Discover how to create a Phoenix umbrella proxy application. Learn about the development process and the benefits of using a proxy application for your Phoenix projects."
slug: "phoenix-umbrella-proxy-application-7kc"
tags: "#elixir #phoenixframework #phoenix #development"
---

Hey everyone!

It's been quite a while since I last wrote here. I've been busy developing games with my free-time company [balconygames](https://balcony.games). We've made good progress, though the market remains challenging due to the high costs of user acquisition.

Today, I'd like to share an example of a proxy application for a Phoenix umbrella project. This might be useful for those facing similar issues with code reloading and WebSocket support. The example has four apps inside the `apps/` directory: `proxy`, `web` (Phoenix), `admin` (Phoenix), and `db` (shared Ecto project).

Without further ado, here's the implementation:

```elixir
defmodule YourApp.Proxy.Application do
  @moduledoc false
  use Application

  alias Phoenix.LiveReloader.Socket, as: LiveReloadSocket

  require Logger

  def start(_type, _args) do
    import Supervisor.Spec, warn: false

    require_code_reloading?(:your_app_web, YourAppWeb.Endpoint)

    opts = [strategy: :one_for_one, name: YourApp.Proxy.Supervisor]
    Supervisor.start_link(children(Mix.env()), opts)
  end

  def children(:test), do: []

  def children(_) do
    proxy_children = [
      {
        Plug.Cowboy,
        scheme: :http,
        plug: YourApp.Proxy.Builder,
        port: port(),
        dispatch: [
          {:_,
           [
             # your_app_web
             web_phoenix_live_reload(),
             web_phoenix_live_view(),
             web_websocket(),
             # your_app_admin
             admin_phoenix_live_reload(),
             admin_phoenix_live_view(),
             admin_websocket(),
             # proxy
             master_proxy()
           ]}
        ]
      }
    ]

    # - proxy endpoints
    #    - /api endpoints
    #    - /dev/admin pages
    # - web watchers for webpacker and code reloading
    # - admin watchers for webpacker and code reloading
    children =
      proxy_children ++
        watcher_children(
          :your_app_web,
          YourAppWeb.Endpoint
        ) ++
        watcher_children(
          :your_app_admin_web,
          YourAppAdminWeb.Endpoint
        )

    children
  end

  defp watcher_children(otp_app, mod) do
    conf = Application.get_env(otp_app, mod)

    unless Mix.env() == :test do
      Enum.map(conf[:watchers], fn {cmd, args} ->
        {Phoenix.Endpoint.Watcher, watcher_args(cmd, args)}
      end)
    else
      []
    end
  end

  defp watcher_args(cmd, cmd_args) do
    {args, opts} = Enum.split_while(cmd_args, &is_binary(&1))
    {cmd, args, opts}
  end

  def port do
    (System.get_env("PORT") || "4000") |> String.to_integer()
  end

  def web_phoenix_live_reload do
    websocket_handler(
      "/phoenix/live_reload/socket/websocket",
      YourAppWeb.Endpoint,
      {LiveReloadSocket, :websocket}
    )
  end

  def web_phoenix_live_view do
    websocket_handler(
      "/live",
      YourAppWeb.Endpoint,
      {Phoenix.LiveView.Socket, :websocket}
    )
  end

  def web_websocket do
    websocket_handler(
      "/cable/websocket",
      YourAppWeb.Endpoint,
      {YourAppWeb.UserSocket, websocket: true}
    )
  end

  def admin_phoenix_live_reload do
    websocket_handler(
      "/dev/admin/phoenix/live_reload/socket/websocket",
      YourAppAdminWeb.Endpoint,
      {LiveReloadSocket, :websocket}
    )
  end

  def admin_phoenix_live_view do
    websocket_handler(
      "/dev/admin/live",
      YourAppAdminWeb.Endpoint,
      {Phoenix.LiveView.Socket, :websocket}
    )
  end

  def admin_websocket do
    websocket_handler(
      "/dev/admin/websocket",
      YourAppAdminWeb.Endpoint,
      {YourAppAdminWeb.UserSocket, websocket: true}
    )
  end

  def master_proxy do
    {:_, Plug.Cowboy.Handler, {YourApp.Proxy.Plug, []}}
  end

  defp websocket_handler(path, endpoint, options) do
    {path, Phoenix.Endpoint.Cowboy2Handler, {endpoint, options}}
  end

  defp require_code_reloading?(otp_app, mod) do
    conf = Application.get_env(otp_app, mod)

    if conf[:code_reloader] do
      Phoenix.CodeReloader.Server.check_symlinks()
    end
  end
end
```

That's it! This proxy application handles routing for both your web and admin Phoenix applications, while properly supporting WebSockets, LiveView, and code reloading.


Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types.

Driving User Engagement: Crystal Blast 2.0 - A Case Study in Mobile Game Iteration

---
title: "Driving User Engagement: Crystal Blast 2.0 - A Case Study in Mobile Game Iteration"
date: "2020-07-20"
description: "Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types."
slug: "new-version-of-crystal-blast-3922"
tags: "#gamedev, #indiegame, #indiegamedev"
---

# New Version of Crystal Blast 2.0 Released!

Hello everyone!

We're excited to announce that we've just published the new version of [Crystal Blast on Google Play](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast) and are currently awaiting review approval for the [App Store version](https://apps.apple.com/us/app/crystal-blast/id1451868968).

## What's New

This update includes several exciting improvements:

- Wonderful new sound effects
- Additional ways to earn coins (allowing players to upgrade their weapons and ships faster)
- Competitive leaderboard system

## Technical Improvements

As part of this build, I've implemented my own game server for:
- Collecting analytics
- Storing player game settings
- Managing the leaderboard

I'm currently working on cleaning up the server-side code and plan to share it with the community as a resource for indie game developers.

## Tech Stack
- Go
- Redis
- ClickHouse
- NSQ
- Ansible + Docker Compose for streamlined deployment

Thank you for your continued support!

Best regards,
Alexandr



Discover how to build a game server for indie developers. Learn about the development process and the benefits of using a game server for your indie games.

Democratizing Game Development: Building Scalable Infrastructure for Independent Studios

---
title: "Democratizing Game Development: Building Scalable Infrastructure for Independent Studios"
date: "2020-06-17"
description: "Discover how to build a game server for indie developers. Learn about the development process and the benefits of using a game server for your indie games."
slug: "started-to-build-game-server-for-indie-developers-1j9m"
tags: "#go #status #gamedev"
---

I haven't written anything for the past few months due to home isolation and being swamped with work. Searching for new freelance contracts to fill my free time became quite exhausting, so I decided to challenge myself with something new.

I've recently started developing a generic-purpose game server for indie developers. So far, I've implemented key-value storage, leaderboards, and guest authentication via device ID. Currently, I'm working on adding social networking features.

I'm aware that Nakama exists as a solution, but creating my own server is both a personal challenge and a practical application for my current games in the market. Starting with version 2.1, Crystal Blast will use my own analytics platform and storage instead of Firebase.

My goal is to move away from external tools like Firebase and game services, bringing everything in-house while keeping costs as low as possible.

I plan to open-source this project in 2-3 months, once I've confirmed it works reliably with games in production.

Update: [Crystal Blast](https://crystalblast.page.link/install) will soon feature sounds, leaderboards, and settings synchronization across platforms using social sign-in.





From Concept to Market Success: The Crystal Blast Development Journey

---
title: "From Concept to Market Success: The Crystal Blast Development Journey"
date: "2020-04-12"
description: "Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types."
slug: "crystal-blast-2-0-303l"
tags: "#gamedev #indiedev #indiegamedev #unity"
---

# Crystal Blast 2.0 - New Release!

We're excited to announce that we've finally published our latest update: [Crystal Blast 2.0](https://crystalblast.page.link/install)!

## What's New:
- 37 new backgrounds
- Completely redesigned gameplay UI
- Improved gameplay balance
- New crystal types

This has been a challenging journey for our team this year. We've dedicated countless nights to development, working on the game during whatever free time we could find.

Today, we received our first purchase since the update, which has given us renewed energy to continue polishing the game:

![First purchase celebration](https://dev-to-uploads.s3.amazonaws.com/i/apgg9a7qi1aihzlrjgxs.png)

Recently, our balcony game development sessions have expanded to include friends who are also working from their balconies due to quarantine restrictions. We hope this situation resolves soon so everyone can fully enjoy the upcoming summer.

[![Crystal Blast 2.0 - Download Now](https://dev-to-uploads.s3.amazonaws.com/i/og7bhvbep8qcasg6u4f2.png)](https://crystalblast.page.link/install)



Discover how to mirror traffic in NGINX using the mirror module. Learn about the development process and the benefits of using the mirror module for your NGINX configuration.

Production-Grade Traffic Analysis: Advanced Load Balancing with NGINX Mirror Module

---
title: "Production-Grade Traffic Analysis: Advanced Load Balancing with NGINX Mirror Module"
date: "2019-12-20"
description: "Discover how to mirror traffic in NGINX using the mirror module. Learn about the development process and the benefits of using the mirror module for your NGINX configuration."
slug: "traffic-mirroring-by-nginx-mirror-module-2i8j"
tags: "#nginx #mirroring #api"
---

# Traffic Mirroring with NGINX Mirror Module

A few months ago, I decided to migrate one of our company services from PHP to Go. This decision came about because we lacked engineers to continue developing or supporting our existing PHP endpoints, while new endpoints were being developed in Go. Although I have substantial experience with Ruby, Go, and JavaScript, I wasn't eager to invest time in enhancing legacy endpoints written years ago.

## The Migration Challenge

When dealing with high-traffic services, choosing the right migration strategy is crucial. While researching options, I discovered the NGINX mirror module in the official documentation: [https://nginx.org/en/docs/http/ngx_http_mirror_module.html](https://nginx.org/en/docs/http/ngx_http_mirror_module.html).

This module seemed like an ideal solution for my use case. To create a prototype, I used Docker Compose to organize all services in one place and implemented logging for basic requests.

## Implementation Example

Here's a simplified version of my setup:

```conf
version: "3"

services:
  entry:
    image: nginx
    volumes:
     - ./v2/nginx.template:/etc/nginx/conf.d/default.conf
    links:
      - v1
      - v2_backend
    ports:
     - "80:80"
    environment:
     - NGINX_PORT=80
    command: /bin/bash -c "exec nginx -g 'daemon off;'"

  v1:
    image: nginx
    volumes:
     - ./v1/nginx.template:/etc/nginx/conf.d/default.conf
    links:
      - v1_backend
    expose:
     - "80"
    environment:
     - NGINX_PORT=80
    command: /bin/bash -c "exec nginx -g 'daemon off;'"

  v1_backend:
    image: example-image1:latest
    expose:
      - "9000"

  v2_backend:
    image: example-image2:latest
    expose:
      - "5000"
```

### PHP Configuration (v1/nginx.template)

This is the NGINX configuration file for the PHP service using FastCGI:

```conf
upstream backend {
  server v1_backend:9000;
}

server {
    listen       80;
    server_name  _;
    root /var/www/html;

    location / {
        try_files $uri $uri/ @rewrite;
    }

    location @rewrite {
      rewrite ^/(.*)$ /index.php?q=$1 last;
    }

    error_page  404              /404.html;
    error_page   500 502 503 504  /50x.html;

    location ~ .php$ {
        try_files  $uri =404;

        fastcgi_pass   backend;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME /var/www/html$fastcgi_script_name;
        include        fastcgi_params;

        fastcgi_max_temp_file_size 0;

        fastcgi_buffers 32 256k;
    }
}
```

### Go Configuration with Mirroring (v2/nginx.template)

This NGINX template serves our new Go API while mirroring traffic to it:

```conf
upstream v1.backend {
    server v1;
}

upstream v2.backend {
    server v2_backend:5000;
}

server {
    listen 80;
    server_name _;

    location / {
      mirror /mirror;
      mirror_request_body on;

      proxy_pass http://v1.backend;
    }

    location = /mirror {
      internal;

      proxy_pass http://v2.backend$request_uri;
      proxy_set_header X-SERVER-PORT $server_port;
      proxy_set_header X-SERVER-ADDR $server_addr;
      proxy_set_header X-Original-URI $request_uri;
      proxy_set_header HOST $http_host;
      proxy_set_header X-REAL-IP $remote_addr;
    }
}
```

## How It Works

This example demonstrates a basic approach to achieve a smooth migration. The PHP application serves as the primary application, while the Go app functions as the V2 API.

The key configuration is `mirror /mirror;`, which instructs NGINX to process each request through the `/mirror` location and then forward it to the v2 backend. This allows us to verify traffic behavior through console logs.

Once the V2 application is functioning correctly, we can completely remove V1 and update the NGINX template to a new version without the mirroring configuration.

## Conclusion

Using NGINX's mirror module provides an elegant solution for gradually migrating between services while ensuring continuity. This approach allows you to validate your new implementation under real traffic conditions before fully committing to the switch.

Thanks for reading!


Discover the latest updates and features of Crystal Blast, the popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types.

Product Evolution in Action: Strategic Feature Development for Crystal Blast Mobile Game

---
title: "Product Evolution in Action: Strategic Feature Development for Crystal Blast Mobile Game"
date: "2019-08-07"
description: "Discover the latest updates and features of Crystal Blast, the popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types."
slug: "game-crystal-blast-the-recent-update-26l3"
tags: "#gamedev #unity #gameart"
---

Hi everyone!

Although we haven't had much time to work lately, we're still dedicating our free time to game development. We hope it becomes profitable in the future! :)

We're excited to announce that we've recently published Crystal Blast on both the App Store and Google Play with several updates.

## Known Challenges We're Facing:

- **Marketing is challenging** - It's incredibly difficult to promote games without purchasing ads. Google and Apple require significant investment to boost games to the top of search results or trending lists. We contacted two publishers, but it seems the gameplay of our [Crystal Blast](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast) isn't as attractive as current Hyper Casual trends. For now, we've tried boosting in specific countries with low cost-per-install and optimized our descriptions to try reaching the top 5 in Google Play searches. Google Play Store works well, but targeting specific audience attributes is much harder compared to Facebook ads.

- **Cross-platform development** - While Unity greatly helps with game development, "cross-platform" doesn't mean it's simple to support Game Center, Google Play Services, push notifications, and other platform-specific features.

- **Analytics platforms** - Google [Firebase](https://firebase.google.com/) is excellent, offering out-of-the-box BigQuery integration on their Pay-as-You-Go plan. It makes it easy to save queries for traffic analysis, and Data Studio is great for building charts based on BigQuery data sources.

- **Distribution tools** - Microsoft [appcenter.ms](appcenter.ms) is fantastic for distributing to testers via Fastlane from a local machine. However, it currently can't distribute Android Bundles, which became a major requirement in Google Play as of August 1st. [Azure](http://azure.microsoft.com) Application Insights is also great, though reviewing events is more challenging compared to Firebase and Data Studio. We're still evaluating both platforms.

- **Push notification systems** - [appcenter.ms](appcenter.ms) lacks robust support for push notification campaigns, whereas [Firebase](https://firebase.google.com/) offers predictions on user churn and makes it much easier to set up notifications for targeted audiences.

- **Game services integration** - [CloudOnce](http://jizc.github.io/CloudOnce/) is a wonderful Unity plugin that supports Play Game Services and Game Center. It's also easy to write your own provider if you want to expand to Amazon or Chinese markets.

We would greatly appreciate any feedback about the game!

P.S.: We're looking for a game art designer to join our team (no profit for now, but lots of fun and potential opportunities to grow together).

More updates coming soon! :)

[Google Play](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast)
[App Store](https://apps.apple.com/us/app/crystal-blast/id1451868968)


Discover why we should sleep. Learn about the development process and the benefits of sleeping.

Work-Life Balance in Tech: Managing Multiple Projects and Continuous Learning

---
title: "Work-Life Balance in Tech: Managing Multiple Projects and Continuous Learning"
date: "2019-03-19"
description: "Discover why we should sleep. Learn about the development process and the benefits of sleeping."
slug: "why-should-we-sleep--50a0"
tags: "#dev"
---

These days I'm working full-time for a great game company from Canada, but at the same time, I would love to do more development work in my free time while still spending quality time with my family. I believe that over the last 10 years, I've become quite addicted to this lifestyle. Everything is progressing so rapidly in web development, game design, and machine learning - it's becoming increasingly easy to learn how to build AI, create designs in Adobe Illustrator, or build robots. Platforms like Coursera, Udemy, and Udacity are making our lives easier, but simultaneously making it harder to choose the right courses due to our limited time.

Why should we sleep when there are so many opportunities around us? :)

Perhaps it's time to invent something for our brains and health that would give us more time for side projects!

Feeling good anyway.


Game in the same style as a classic snake

Reimagining Classic Gaming: Modern Snake Game Development with Advanced Mechanics

---
title: "Reimagining Classic Gaming: Modern Snake Game Development with Advanced Mechanics"
date: "2019-03-15"
description: "Game in the same style as a classic snake"
slug: "gamedev-snake-1f5f"
tags: "#gamedev #unity #gameart"
---

Hi everyone!

I'm excited to announce that I've just released a new game! However, for upcoming releases, I'll be focusing on adding nice features to my previous games rather than creating new ones. I've started learning Adobe Animation, which reminds me of Flash that I used years ago.

Continuing this development journey has become more challenging, but I'm planning to dedicate more of my free time to animation or possibly find someone to collaborate with on this aspect.

[https://play.google.com/store/apps/details?id=com.balconygames.snake](https://play.google.com/store/apps/details?id=com.balconygames.snake)

I hope you'll find this game to be a great time-killer! :)

Thank you for reading!

![screenshot1](https://thepracticaldev.s3.amazonaws.com/i/14fyjjrhqz2lmz7olh7y.png)
![screenshot2](https://thepracticaldev.s3.amazonaws.com/i/4ayjli3rat53x9hi035t.png)



Hyper-Casual Gaming Strategy: Creating Addictive Gameplay Experiences

---
title: "Hyper-Casual Gaming Strategy: Creating Addictive Gameplay Experiences"
date: "2019-02-27"
description: Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types.
slug: "dont-fall-5g8h"
tags: "#gamedev #unity #gameart"
---

Hi everyone!

I'm excited to announce that I've just published my new game on Google Play!

While there's nothing particularly complex about the development process to share right now, I did try something new on the technical side. I decided to experiment with [Microsoft App Center](https://appcenter.ms) for this project. Microsoft has created a nice SDK for mobile developers that provides an analytics dashboard and easy setup for push notifications (including basic audience targeting based on tracked events).

The only limitation I encountered is that the build system isn't fully compatible with Unity development yet. App Center allows you to build and distribute Android and iOS projects to stores, but it doesn't support custom setups for exporting builds from Unity to Xcode or Gradle projects.

I'm planning to work around this by using GitLab hooks to export the projects to Xcode and Gradle submodules, then push them to GitHub. This is necessary because App Center doesn't yet support GitLab as a repository sync option.

You can check out the game here: [Don't Fall on Google Play](https://play.google.com/store/apps/details?id=com.balconygames.dontfall)

I hope you'll find it to be a fun time-killer app!

Thank you for reading!

![screenshot1](https://thepracticaldev.s3.amazonaws.com/i/huqad1rsdby3e3aypfzt.png)
![screenshot2](https://thepracticaldev.s3.amazonaws.com/i/enbkz0r2sbu5rp8zwtjf.png)
![screenshot3](https://thepracticaldev.s3.amazonaws.com/i/6n43mbeyjjne4uoz1yhj.png)





Our new game published on Google Play and App Store.

Mobile Gaming Excellence: Building Engaging Casual Games for Mass Market Appeal

---
title: "Mobile Gaming Excellence: Building Engaging Casual Games for Mass Market Appeal"
date: "2019-02-14"
description: Our new game published on Google Play and App Store.
slug: "crystal-blast-9g1"
tags: "#gamedev #unity #startup"
---

Hi everyone!

A few days ago, we published our new game. No ads, no payments - it's all about the fun! We're still facing some technical challenges as game development is a new area for us.

We're hoping the community might be able to help us solve an issue we can't handle on our own.

We're using Unity, which is an awesome platform for rapidly prototyping games across multiple platforms.

## The Issue We're Facing:

For our other game ([Sweety Jumper](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper)), we added in-app purchases and Google Ads packages to the Android build. While it compiles successfully, after installation on Android devices, the ads don't display and it's impossible to make purchases in either production or beta testing modes. Interestingly, the iOS version works perfectly fine.

Has anyone experienced similar issues when building for Android from Unity? We suspect it might be related to JAR dependencies in the APK build process, but we're not sure how to resolve it.

Any suggestions on how to properly debug this would be greatly appreciated!

## Our New Game

Our latest release is [Crystal Blast](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast)

## Support Us on Product Hunt:
- [Upvote Sweety Jumper](https://www.producthunt.com/posts/sweety-jumper)
- [Upvote Crystal Blast](https://www.producthunt.com/posts/crystal-blast)

If you have time, please try our game and leave a review. We would really appreciate it!

Thank you for reading!

![image1](https://thepracticaldev.s3.amazonaws.com/i/f9nezuzng1584d0ohjye.png)
![image2](https://thepracticaldev.s3.amazonaws.com/i/wxe01vj66150r979iz2o.png)
![image3](https://thepracticaldev.s3.amazonaws.com/i/gggekuxlcwesvp4michr.png)
![image4](https://thepracticaldev.s3.amazonaws.com/i/qgxvnpq8cy2rojhcqvzr.png)
![image5](https://thepracticaldev.s3.amazonaws.com/i/1bncnwcm9lo6qmho4y0s.png)


Discover how to use UnityWebRequest for your REST API. Learn about the development process and the benefits of using UnityWebRequest for your REST API.

Enterprise Unity Development: Implementing Robust REST API Integration Strategies

---
title: "Enterprise Unity Development: Implementing Robust REST API Integration Strategies"
date: "2019-01-03"
description: "Discover how to use UnityWebRequest for your REST API. Learn about the development process and the benefits of using UnityWebRequest for your REST API."
slug: "how-to-use-unitywebrequest-for-your-rest-api-23e0"
tags: "#unity #restapi #webgl"
---

When I started working with Unity, my goal was to create a cross-platform game that could be deployed across multiple platforms: App Store, Google Play, Amazon, Facebook, Web, and Chrome Extension. While this approach sounds great in theory, it requires careful consideration of the libraries you plan to use.

Initially, I decided to use [HttpClient](https://assetstore.unity.com/packages/tools/network/http-client-79343) based on the `System.Net` namespace. However, when compiling to WebGL, I discovered that `System.Net` and `HttpClient` were excluded from the build, breaking the connection between my game and API.

The solution? Use `UnityWebRequest`.

Below are examples of how to build GET and POST requests with JSON using UnityWebRequest.

```C#
using System;
using System.Collections.Generic;
using UnityEngine.Networking;
using System.Collections;
using Newtonsoft.Json;
using UnityEngine;
using System.Text;

namespace Jumper.Network
{
    public abstract class API
    {
        // TODO: add https certificate verification
#if UNITY_WEBGL
        // WebGL version is loaded by browser under https protocol.
        public const string HOST = "https://api.example.com/client/";
#else
        public const string HOST = "http://api.example.com/client/";
#endif

        public static readonly string TOKEN_QUERY_PARAM = "?token=";
        public static readonly string REGISTER_PATH = "users/register";

        private const string USER_ID_KEY = ":user_id";

#region internal methods for http client
        internal static string path(string path, Dictionary<string, string> properties)
        {
            // In case the user has no user_id (possibly due to missing internet connection on boot)
            // we should use the /games namespace for sending requests.
            if (properties.ContainsKey(USER_ID_KEY) && !string.IsNullOrEmpty(properties[USER_ID_KEY]))
            {
                return resolve(
                    GAME_PATH + "/:game_id/sessions/:user_id/" + path + TOKEN_QUERY_PARAM + ":token",
                    properties);
            }

            return resolve(
                GAME_PATH + "/:game_id/" + path + TOKEN_QUERY_PARAM + ":token",
                properties);
        }

        internal static string resolve(string path, Dictionary<string, string> properties)
        {
            foreach(var kv in properties)
            {
                path = path.Replace(kv.Key, kv.Value);
            }

            return path;
        }

        internal static string requestError(UnityWebRequest request)
        {
            string responseBody = string.Empty;
            if (request.downloadHandler != null)
            {
                responseBody = request.downloadHandler.text;
            }

            return string.Format(
                "[api#error] request status code: {0}, data: ======= response: {1}, error: {2} =======",
                request.responseCode, responseBody, request.error);
        }

        internal static T requestResponse<T>(UnityWebRequest request)
        {
            try
            {
                var responseData = request.downloadHandler.text;
                return JsonConvert.DeserializeObject<T>(responseData);
            }
            catch (Exception ex)
            {
                Debug.Log(ex.Message);
                return default(T);
            }
        }

        public const string CONTENT_TYPE_JSON = "application/json";

        /// <summary>
        /// Create the instance of authenticated http client.
        /// </summary>
        /// <returns>The client.</returns>
        internal static IEnumerator Request(string url, string method, string data = null, Action<UnityWebRequest> done = null)
        {
            UnityWebRequest request;

            switch(method)
            {
                case UnityWebRequest.kHttpVerbGET:
                    request = UnityWebRequest.Get(url);
                    yield return request.SendWebRequest();
                    done?.Invoke(request);
                    break;
                case UnityWebRequest.kHttpVerbPOST:
                    request = UnityWebRequest.Post(url, data);
                    request.method = UnityWebRequest.kHttpVerbPOST;
                    request.downloadHandler = new DownloadHandlerBuffer();
                    request.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(data));
                    request.SetRequestHeader("Content-Type", CONTENT_TYPE_JSON);
                    request.SetRequestHeader("Accept", CONTENT_TYPE_JSON);
                    yield return request.SendWebRequest();
                    done?.Invoke(request);
                    break;
            }
        }

        internal static IEnumerator Post(string url, object o, Action<UnityWebRequest> done = null) =>
            Request(url, UnityWebRequest.kHttpVerbPOST, JsonConvert.SerializeObject(o), done);

        internal static IEnumerator Get(string url, Action<UnityWebRequest> done = null) =>
            Request(url, UnityWebRequest.kHttpVerbGET, null, done);

        internal static Action<T1, T2> wrapCallback<T1, T2>(Action<T1, T2> doneCallback)
        {
            // In case of having a missing done callback, use an empty function
            // to avoid null checks when invoking the callback.
            return doneCallback ?? ((_arg1, _arg2) => { });
        }
    }
#endregion
}

```C#
// Example of using Api.cs

using Newtonsoft.Json;
using UnityEngine;
using System.Collections.Generic;
using System;
using System.Collections;

namespace Jumper.Network
{
    public class Users : API
    {
        public static IEnumerator Create(
            Dictionary<string, string> properties, User user,
            Action<User, string> doneCallback = null)
        {
            var done = wrapCallback(doneCallback);

            try
            {
                return Post(path(REGISTER_PATH, properties), user,
                    (request) =>
                    {
                        if (request.isNetworkError || request.responseCode != 201)
                            done(null, requestError(request));
                        else
                            done(requestResponse<User>(request), null);
                    });
            }
            catch (Exception ex)
            {
                // Catch all exceptions to ensure the application never crashes
                Debug.Log(ex.Message);
                done(null, ex.Message);
            }

            return null;
        }
    }
}

```C#
// Example from MonoBehaviour

StartCoroutine(Users.Create(
                Api.GameProperties, Api.CurrentUser, (user, err) =>
                {
                    if (err != null)
                    {
                        Debug.LogError(err);
                    }
                    else
                    {
                        // good to go
                    }
                }));
```


Discover how I am using Kubernetes for game development. Learn about the development process and the benefits of using Kubernetes for your game development.

Scaling Game Infrastructure: Why Modern Game Studios Choose Kubernetes Architecture

---
title: "Scaling Game Infrastructure: Why Modern Game Studios Choose Kubernetes Architecture"
date: "2019-01-03"
description: "Discover how I am using Kubernetes for game development. Learn about the development process and the benefits of using Kubernetes for your game development."
slug: "why-i-am-using-kubernetes-for-gamedev-2n14"
tags: "#docker #kubernetes #unity #gamedev"
---

Hi everyone!

It's a great time to share a post about an exciting new area I've been learning and building in. Game development has always been my goal since I started learning software development, but for various reasons, I've always been busy with other projects.

But enough about the past. Kubernetes is a truly exciting technology that I discovered while working as a solo developer on my backend and frontend projects.

## My Current Stack

- [DigitalOcean](https://digitalocean.com) - A hosting platform with reasonable pricing that's perfect for my indie projects. I want to thank the company for always being open to help, providing credits, and offering competitive prices.

- [Containership.io](https://containership.io) - A fantastic platform for provisioning Kubernetes on DigitalOcean. (I don't have any credits from them, but their platform has saved me significant time). While DigitalOcean now provides Kubernetes out of the box, I found it challenging as a beginner, especially when dealing with pods, services, and SSL certificate setup. This might just be my experience - I had better luck when I had full access to Kubernetes.

- [Kubernetes](https://kubernetes.io) - It's not just about microservices. Think of it as Heroku but with complete control through simple recipes.

- [Gitlab](https://gitlab.com) - A source control platform with free container registry for each repository.

## What My Cluster Hosts

- [https://api.balconygames.com](https://api.balconygames.com) - A Go server communicating with PostgreSQL (3 replicas)
- [https://dashboard.balconygames.com](https://dashboard.balconygames.com) - A ReactJS admin dashboard for game management (nginx + static)
- [https://sweety-jumper.balconygames.com](https://sweety-jumper.balconygames.com) - A Unity game (nginx + static) currently in development mode due to network issues
- [https://balconygames.com](https://balconygames.com) - Jekyll site (nginx + static)
- PostgreSQL (deployed using helm recipes)
- Letsencrypt for monitoring SSL certificates and creating new ones

The entire setup costs me about **$40** per month (3 nodes at **$10** each plus 1 Node Balancer), which is remarkably affordable for these resources.

## My Workflow as a Solo Backend Developer

1. Make code changes
2. Rebuild the image and push to Gitlab registry
3. Run `kubectl apply -f recipe/<name of the app>/deployment.yml` which contains `<image_name>:latest` or `<image_name>:$COMMIT_TAG`

My next step is to move this process away from my local machine and use Gitlab pipelines instead. This setup is easy to support and deploy, and it saves me valuable time.

If I ever need to set up Redis or other databases, I'll use the helm tool with predefined recipes to create pods, services, and deployments.

**Our game is [Sweety Jumper](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper)**


Game development is another side of software development

Mastering Game Development Complexity: Strategic Approaches to Interactive Entertainment

---
title: "Mastering Game Development Complexity: Strategic Approaches to Interactive Entertainment"
date: "2019-01-02"
description: "Game development is another side of software development"
slug: "game-development-is-hard-1bpc"
tags: "#gamedev #unity #gameart"
---

Over the past few weeks, my friends and I have been working on creating a game from scratch in our free time, despite having no prior experience in this area. Let me share how it all began.

My friend and I were sitting in a nice bar, enjoying some cool wines. We were talking about life after 30 and reminiscing about the awesome times we had playing console games when we were younger. These days, we rarely have enough time to play. I'm a backend developer, and he was working as a developer for accounting software (though he recently started learning JavaScript and found his first job in frontend development). I told him about my school days when I learned Macromedia Flash to build small games.

Then my friend Igor said:

"You know, I have a friend named Vitaly who works in a grocery shop but also wants to build games."

And that's how it started. Three people from completely different backgrounds coming together.

We decided to use Unity because it seemed like the fastest way to build a game these days.

I focused on the backend part and developing an HTTP client for Unity to communicate with the server.

Our journey looked something like this:

0. What's the idea for the game? After talking with friends and drawing inspiration from tutorials, we settled on a concept and decided to build it into a product.
1. Where to get assets? This was challenging, but we searched the Unity store. Thanks to Black Friday prices, we spent $45 and got a UI asset package.
2. Where to get player assets? We searched online, found suitable assets, contacted the owner, got approval, and updated the info popup in the game.
3. Test, test, and test again.
4. How to earn money? We added in-app purchases and an option to watch ads to continue playing, but we designed it so it doesn't break the gameplay. You can still enjoy the game without spending money, and the ads aren't intrusive.
5. Get feedback. We implemented gyroscope controls, but based on feedback, we might need to change this approach.
6. Currently, our game is available on Google Play: [Sweety Jumper - Android](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper).
7. We don't have a marketing budget or ads to promote the app yet. This would require more investment, but hopefully, if people like it, word-of-mouth might be enough!
8. I would recommend using gameanalytics.com to track your users (DAU, MAU) - at the very least, you'll have statistics about your players.

In future articles, I'll try to describe the main challenges beginners face when using Unity and getting started with game development.

Our Games (hopefully more than one in the future!):
[Sweety Jumper - Android](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper)

Social Media:
[Twitter](https://twitter.com/balconygames)
[Instagram](http://instagram.com/balconygames)
[Facebook](http://facebook.com/balconygames)
[Website](https://balconygames.com/)

Screenshots:

![screenshot](https://thepracticaldev.s3.amazonaws.com/i/e8wsylpe0lw7pm8zp12a.png)
![screenshot](https://thepracticaldev.s3.amazonaws.com/i/xb6volcz6f1wajqbswof.png)
![screenshot](https://thepracticaldev.s3.amazonaws.com/i/c9tl6acvew8h2c58v8to.png)
![screenshot](https://thepracticaldev.s3.amazonaws.com/i/200xo7ljggeseg95i2rv.png)




Discover how to write test cases for your Apache Logstash filters. Learn about the development process and the benefits of using RSpec for your Logstash filters.

Enterprise Data Processing: Test-Driven Development for Logstash Pipelines

---
title: "Enterprise Data Processing: Test-Driven Development for Logstash Pipelines"
date: "2018-08-09"
description: "Discover how to write test cases for your Apache Logstash filters. Learn about the development process and the benefits of using RSpec for your Logstash filters."
slug: "write-test-cases-for-your-apache-logstash-filters-ah3"
tags: "#logstash #rspec #docker #ruby"
---

About a year ago, I started working on an ELK (ElasticSearch, Logstash, Kibana) setup for a BI platform. While processing events in Logstash, I found it frustrating to work with filter changes, especially when dealing with complex regular expressions, structures, or conditions.

Having extensive experience in Ruby on Rails development, I decided to leverage RSpec test cases to cover my Logstash filters. This approach made sense since Logstash uses JRuby internally for its packages and extensions.

I also wanted to containerize everything with Docker to avoid installing Logstash and gems on my local machine.

Let's start with the Dockerfile and then build out the project structure step by step.

```Dockerfile
FROM logstash:2.4

# Install Rspec related dependencies
RUN logstash-plugin install --development

# Install prod dependencies
RUN logstash-plugin install logstash-filter-prune

ARG ES_PLUGIN=logstash-output-elasticsearch-6.2.4-java.gem
ARG KAFKA_PLUGIN=logstash-input-kafka-7.0.0.gem

COPY gems/${ES_PLUGIN} /tmp/${ES_PLUGIN}
RUN logstash-plugin install /tmp/${ES_PLUGIN}

COPY gems/${KAFKA_PLUGIN} /tmp/${KAFKA_PLUGIN}
RUN logstash-plugin install /tmp/${KAFKA_PLUGIN}
```

The `gems/` directory contains frozen gem versions for our Logstash setup.

For a more efficient way to run test cases, let's define a Makefile:

```Makefile
NAME = your_logstash

build:
	docker build -t $(NAME) .
.PHONY: build

clean:
	docker rmi --force $(NAME)
.PHONY: clean

test:
	@docker run --rm -t -i \
		-v `pwd`/../:/app \
		-w /app \
		$(NAME) \
		/bin/bash -c "rspec /app/logstash/spec/$(TEST_CASE)"
.PHONY: test

console:
	@docker run --rm -t -i \
		-v `pwd`/../:/app \
		-w /app \
		$(NAME) \
		/bin/bash
.PHONY: console
```

- `make test` runs RSpec inside your container
- `make console` opens an interactive terminal inside the Docker container for manual execution and debugging (using `binding.pry`) of your specs

Now, let's create our `spec/spec_helper.rb`, which forms the foundation of our RSpec setup:

```ruby
require "logstash/devutils/rspec/spec_helper"
require 'rspec'
require 'rspec/expectations'

require 'ostruct'
require 'erb'
require 'yaml'
require 'json'

# Running the grok code outside a logstash package means
# LOGSTASH_HOME will not be defined, so let's set it here
# before requiring the grok filter
# (coming from the original examples for logstash specs)
unless LogStash::Environment.const_defined?(:LOGSTASH_HOME)
  LogStash::Environment::LOGSTASH_HOME = File.expand_path("../", __FILE__)
end

module Helpers
  ROOT_PATH = File.dirname(File.expand_path(__FILE__))
  TEMPLATES_PATH = File.join(ROOT_PATH, '..', 'conf.d/')

  def load_fixture(filename, settings = {})
    message = File.read(File.join(ROOT_PATH, 'fixtures', filename))
    settings.merge('message' => message)
  end

  def load_filter(filename, render_vars = {})
    content = File.read(File.join(TEMPLATES_PATH, filename))

    render_vars = OpenStruct.new(render_vars)

    # This isn't the most elegant solution, but it's the simplest way to handle
    # Jinja2-style variable replacement
    template = ERB.new(content.gsub('{{', '<%=').gsub('}}', '%>'))
    template.result(render_vars.instance_eval { binding })
  end
end

require "logstash/filters/grok"
```

In my Logstash filters, I use Jinja2-style syntax (`{{ }}`) for variable replacement, which gets handled by Ansible during deployment.

Now we're ready to define an actual spec to test our Logstash filter. Let's assume we want to parse a line like `username=<username>`. We'll create a `filter_spec.rb` file inside the `spec/filters` folder. Filters should focus solely on processing logic, not input or output statements.

```ruby
require_relative '../spec_helper'

describe 'elb' do
  extend Helpers

  # Set config using our defined filter in `conf.d/01-filter.conf` file
  config load_filter('01-filter.conf')

  # You can define in spec/fixtures/sample1.txt
  # Example: username=oivoodoo
  sample(load_fixture('sample1.txt', 'type' => 'your-source-data')) do
    insist { subject.get('username') } == 'oivoodoo'
  end
end
```

And here's our filter configuration:

```conf
filter {
  if [type] == "{{ type }}" {
    grok {
      match => {
        "message" => [
          "%{WORD:username}"
        ]
      }
    }

    prune {
      blacklist_names => [
        "@version",
        "message"
      ]
    }
  }
}
```

This approach has proven extremely valuable for saving time compared to deploying changes and waiting for new data. It's also easy to add a `ruby` filter inside your configuration and use `binding.pry` to inspect the `event` object during debugging.


Learn how to automate invoice generation using Python and Wunderlist API. This tutorial shows how to track billable hours in Wunderlist tasks and generate CSV reports for invoicing clients based on time entries.

Freelance Automation: Streamlining Client Billing with API Integration

---
title: "Freelance Automation: Streamlining Client Billing with API Integration"
date: "2018-08-01"
description: "Learn how to automate invoice generation using Python and Wunderlist API. This tutorial shows how to track billable hours in Wunderlist tasks and generate CSV reports for invoicing clients based on time entries."
slug: "build-invoices-based-on-wunderlist-41op"
tags: "#python #freelance"
---

For the past 8 years, I've been working remotely on contract jobs. For clients who pay by the hour, I need to send invoices every two weeks. I tried various invoicing applications before eventually settling on Google Docs.

Then I discovered Wunderlist, a nice to-do list application. I created Shopping and TODO lists and began using it daily. It quickly became a habit for me to record tasks there. I realized it would be perfect for tracking my billable hours as well.

I use the following format for tracking time in tasks:

```
<hours> hours TASK-1
<minutes> minutes TASK-2
<days> days TASK-3
```

After a month of tracking my time this way, I wanted to download this data and calculate the hours I'd spent during the month. So I created a script to generate a CSV report of my hours.

```python
import wunderpy2

from dateutil import parser
from datetime import date
from csv import writer


ACCESS_TOKEN = '<WUNDERLIST_ACCESS_TOKEN>'
CLIENT_ID = '<WUNDERLIST_CLIENT_ID>'
PROJECT_BOARD = 'LIST_TITLE'
HOUR_RATE = 1


def __build_hour(task):
    '''
    Parses task titles in formats like:
        dict(title='1 hour CORE-1234')
        dict(title='5 hours CORE-4321')
        dict(title='1 minute CORE-1234')
    '''
    columns = task['title'].strip().split(' ')
    time, measure, task_id = columns
    if measure == 'hour' or measure == 'hours':
        hours = float(time)
    elif measure == 'minute' or measure == 'minutes':
        hours = float(time) / 60
    elif measure == 'day' or measure == 'days':
        hours = 24 * float(time)
    else:
        raise ValueError('Unknown time measure in task title: ' + task['title'])

    return dict(
        task_id=task_id,
        created_at=parser.parse(task['created_at']),
        hours=hours)


def __main__():
    api = wunderpy2.WunderApi()
    client = api.get_client(ACCESS_TOKEN, CLIENT_ID)
    board = [l for l in client.get_lists() if l['title'] == PROJECT_BOARD][0]
    active_tasks = [t for t in client.get_tasks(board['id']) if not t['completed']]
    report = [__build_hour(task) for task in active_tasks]

    estimated_earnings = sum([task['hours'] for task in report]) * HOUR_RATE
    print(estimated_earnings)

    with open(f"report-{date.today()}.csv", 'w+') as f:
        w = writer(f)
        rows = [[task['task_id'], task['hours'], task['created_at'].date()]
                for task in report]
        w.writerows(rows)

    for task in active_tasks:
        client.update_task(task['id'], task['revision'], completed=True)

    # TODO: make monthly output report to pdf file based on created_at field.


if __name__ == '__main__':
    __main__()

```



Discover how to test your REST API in VueJS. Learn about the development process and the benefits of using VueJS for your REST API testing.

Quality Assurance Excellence: Advanced REST API Testing Methodologies in Vue.js

---
title: "Quality Assurance Excellence: Advanced REST API Testing Methodologies in Vue.js"
date: "2018-04-11"
description: "Discover how to test your REST API in VueJS. Learn about the development process and the benefits of using VueJS for your REST API testing."
slug: "testing-rest-api-in-vuejs-5126"
tags: "#javascript #vue #vuejs #js"
---

I recently started working with `VueJS` to build dashboard prototypes for analytics at my company. The simplicity of `VueJS` has quickly made it my favorite tool for JavaScript application development. While `EmberJS` developers commonly use the Mirage library to stub API calls and generate response bodies, for `VueJS` I've found [vue-resource-mock](https://github.com/noru/vue-resource-mock) to be an excellent alternative.

Let me share some examples to demonstrate how to use this powerful library:

```javascript
// main.js
...
import VueResource from 'vue-resource'
import VueResourceMock from 'vue-resource-mock'
import MockData from './mock/data.js'

Vue.use(VueResource)

if (process.env.NODE_ENV === 'development') {
  Vue.use(VueResourceMock, MockData)
}
...
```

```javascript
// mock/data.js

const id = () => Math.floor(Math.random() * 100)

export default {

  ['GET */example'] (pathMatch, query, request) {
    let body = {
      collection1: [
        { id: id(), name: 'name1' },
        { id: id(), name: 'name2' },
      ]
    }

    return {
      body: body,
      status: 200
    }
  }
}
```

The best part is that your component code remains unchanged. Simply make HTTP requests as usual, and you'll receive the mocked data during development:

```javascript
...

      this.$http
        .get(`${process.env.API_HOST}/example`)
        .then(response => {
          let { collection1 } = response.body
          this.$store.commit('setCollection1', collection1)
        })
...
```


Discover how to deploy an Ember application to a Kubernetes cluster. Learn about the deployment process and the benefits of using Kubernetes for scalable web applications.

Cloud-Native Development: Strategic Ember.js Deployment on Kubernetes Infrastructure

---
title: "Cloud-Native Development: Strategic Ember.js Deployment on Kubernetes Infrastructure"
date: "2018-04-05"
description: "Discover how to deploy an Ember application to a Kubernetes cluster. Learn about the deployment process and the benefits of using Kubernetes for scalable web applications."
slug: "how-to-deploy-ember-app-to-kubernetes-2i2m"
tags: "#kubernetes #emberjs #javascript #docker"
---

As part of my unfinished project [observerio](github.com/observerio/observer-server), I was working on my first Ember dashboard. After completing the prototype, I decided to deploy it as a pod in a Kubernetes cluster on DigitalOcean. Why Kubernetes? It can save a lot of time if you're a solo developer without enough resources to support a non-profitable idea.

During my first deployment, I found it relatively easy to build a release version of the Ember app. However, when opening the dashboard in a browser, I discovered that my routing wasn't working properly. After searching for solutions online, someone suggested modifying the Nginx settings when serving the Ember app.

Here's the [Docker.release](https://github.com/observerio/observer-server/blob/master/web/Dockerfile.release) file used by the pod:

```Dockerfile
FROM alpine:3.6

COPY dist/ /app

WORKDIR /app

CMD ["tail", "-f", "/dev/null"]

```

I needed to figure out how to change the Nginx settings. Since I wasn't familiar with the internal workings of Kubernetes, my next step was to explore the containers running in the Kubernetes cluster. In the ingress pod I found the Nginx template used for serving my Ember pod.

[nginx.tmpl](https://github.com/kubernetes/ingress-nginx/blob/master/rootfs/etc/nginx/template/nginx.tmpl)

To ensure I was working with the same template as the installed ingress container, I copied [nginx.tmpl](https://github.com/observerio/observer-server/blob/master/deployment/app-deploy/ingress/templates/nginx.tmpl#L458) from the container and added the following configuration (at line 458):

```
{{ if and (eq $path "/") (eq $server.Hostname "observer.rubyforce.co") }}
            try_files $uri $uri/ /index.html?/$request_uri;
{{ end }}
```

Then changed ingress controller to use the new template via config map, example of [Deployment](https://github.com/observerio/observer-server/blob/master/deployment/app-deploy/ingress/03-deployment.yml#L67)

Probably it could be helpful for someone as well.

Thanks for reading!


Learn how to automate browser interactions using Python and Docker to scrape data from web dashboards without an API. This tutorial shows how to set up a containerized Chrome browser for web automation using Splinter and Docker.

Scalable Test Automation: Enterprise Browser Testing with Docker and Python

---
title: "Scalable Test Automation: Enterprise Browser Testing with Docker and Python"
date: "2018-04-03"
description: "Learn how to automate browser interactions using Python and Docker to scrape data from web dashboards without an API. This tutorial shows how to set up a containerized Chrome browser for web automation using Splinter and Docker."
slug: "browser-automation-using-docker-and-python-2j2o"
tags: "#python #selenium #docker"
---

A few weeks ago, I was working on a new report for a customer's game. The platform providing campaign reports didn't have a public API to generate reports on demand with any kind of developer access key.

However, it was possible to request these reports through their dashboard. While it might seem odd to rely on a UI for downloading such reports, it was the only way to access the customer's valuable data.

Let's define the requirements for this project:

- It should be a standalone Python script for easy execution and integration with existing ETL libraries
- It shouldn't require extra software on the server except for the Docker package (which is quite flexible)

Now we're ready to build something functional. In this post, I'll use specific libraries to access the Docker process due to the version of packages installed in CentOS (in my example).

My requirements.txt:

```
docker==2.1.0
splinter==0.7.7
timeout-decorator==0.3.3
```

[Splinter](https://splinter.readthedocs.io/en/latest/) is a nice library that wraps browser drivers for automating interactions with web pages.

Let's define a class for running a `Google Chrome` container. Later, we'll use it to access web pages via the `splinter` library.

```python
class _ChromeContainer:
    '''
    _ChromeContainer handles running a Chrome Docker container
    in the background.

    Requires Docker service on the machine to pull and run images.
    '''
    def __init__(self):
        self.__image_name = "selenium/standalone-chrome:3.10.0"
        self.__client = docker.from_env()

    def run(self):
        '''
        Starts up a Docker container with chromedriver and waits for it to reach running state
        '''
        client = self.__client

        self.container = client.containers.run(self.__image_name,
                                               detach=True,
                                               ports={'4444/tcp': None})

        @timeout_decorator.timeout(120)
        def waiting_up(client: docker.client.DockerClient, container):
            while True:
                container.reload()
                if container.status == "running":
                    break
                time.sleep(1)

        waiting_up(client, self.container)

    def quit(self):
        '''
        Kills and deletes the container
        '''
        self.container.kill()

    @property
    def public_port(self):
        container = self.__chrome_container.container
        return container.attrs["NetworkSettings"]["Ports"]["4444/tcp"][0]["HostPort"]
```

Now we're ready to use `splinter` and `_ChromeContainer` to automate our task.

```python
import timeout_decorator
import docker
from splinter import Browser


class Worker:
    def __init__(self):
        self.__chrome_container = _ChromeContainer()

    def process(self):
        self.__chrome_container.run()

        self.__web_client = Browser('remote',
                                    url="http://127.0.0.1:{}/wd/hub".format(self.__chrome_container.public_port),
                                    browser='chrome')

        # Example for login request:
        try:
            self.__login()
        finally:
            self.__web_client.quit()
            self.__chrome_container.quit()

    def __login(self):
        self.__web_client.visit("http://www.example.com/login")
        self.__web_client.fill('developer_session[email]', 'EXAMPLE_USERNAME')
        self.__web_client.fill('developer_session[password]', 'EXAMPLE_PASSWORD')
        button = self.__web_client.find_by_id('developer_session_submit')
        button.click()
```

This is just an example, and you can extend it with similar steps like `__login` in your `Worker` class to accomplish more complex automation tasks.

Thank you for reading! :)





Discover how to implement a TCP server and client in Elixir. Learn about the development process and the benefits of using TCP for communication between applications.

High-Performance Network Architecture: Building Scalable TCP Solutions with Elixir

---
title: "High-Performance Network Architecture: Building Scalable TCP Solutions with Elixir"
date: "2018-04-03"
description: "Discover how to implement a TCP server and client in Elixir. Learn about the development process and the benefits of using TCP for communication between applications."
slug: "elixir-tcp-server-example--foo"
tags: "#elixir #tcp #server #client"
---

This post is about an unfinished project called [observerio](github.com/observerio/observer-server) that I haven't had enough free time to complete recently.

I've been working on this project to enable real-time testing of different game strategies. The result is a project with an HTTP API, TCP server, Ember dashboard, and a core library based on Go (using xgo compilation for cross-platform support).

I'd like to share some examples that might be useful for others.

## Why Elixir?

If someone asked me why I chose Elixir for the backend, I'd find it hard to explain precisely. I was likely inspired by my previous experience at my startup [musicfeed](http://musicfeed.co/). Elixir has an elegant syntax, a supportive community, and excellent documentation. However, concepts like gen_server and other tools can be complex to understand if you're learning Elixir as your first programming language. While some might tell you that you don't need to learn Erlang to use Elixir, that's only partially true, though the number of Elixir libraries is growing rapidly.

## Project Architecture

I decided to use a TCP server and client to send variables and logs from mobile games via an internal SDK. When the TCP server receives variables or logs, it publishes messages through PubSub (gateway) to subscribed WebSocket handlers. If a WebSocket connection is active, it automatically publishes the changes to the Ember dashboard. This might sound more like a fun experiment than a production-ready solution, but I built it for enjoyment anyway!

Let's review the TCP server implementation (please feel free to suggest improvements, as this is open source):

[tcp.ex](https://github.com/observerio/observer-server/blob/master/lib/web/tcp.ex)

## Supervisors for TCP Server and Client

First, we define supervisors for the TCP server and client. The client supervisor is used to create communication between the WebSocket (via PubSub) and the TCP client:

```elixir
defmodule Web.Tcp.ServerSupervisor do
  use Supervisor

  def start_link do
    Supervisor.start_link(__MODULE__, [], name: :tcp_server_supervisor)
  end

  def init(_) do
    children = [
      worker(Web.Tcp.Server, [])
    ]

    supervise(children, strategy: :one_for_one)
  end
end

defmodule Web.Tcp.ClientSupervisor do
  use Supervisor

  def start_link do
    Supervisor.start_link(__MODULE__, [], name: :tcp_client_supervisor)
  end

  def start_client(token) do
    Supervisor.start_child(:tcp_client_supervisor, [token])
  end

  def init(_) do
    children = [
      worker(Web.Tcp.Client, [])
    ]

    # We use the `simple_one_for_one` strategy.
    # With this strategy, we define just a "template" for a child,
    # no process is started during the Supervisor initialization, only
    # when we call `start_child/2`
    supervise(children, strategy: :simple_one_for_one)
  end
end
```

## Server Worker

Next, we define the server worker and pass the module name `Web.Tcp.Handler` as the entry point for processing connected clients:

```elixir
defmodule Web.Tcp.Server do
  require Logger

  def start_link do
    Logger.debug("[tcp] starting server on port :#{_port()}")
    opts = [port: _port()]
    {:ok, _} = :ranch.start_listener(
      :tcp, _acceptors_size(), :ranch_tcp, opts, Web.Tcp.Handler, [])
  end

  def _port do
    String.to_integer Application.get_env(:web, :tcp_port)
  end

  def _acceptors_size do
    String.to_integer Application.get_env(:web, :tcp_acceptors_size)
  end
end
```

## Client Worker

Now we define a module that works as a worker for connected TCP clients. On initialization, it subscribes to a PubSub channel using the API key (per user). This allows it to receive messages from PubSub and send them back to the TCP client socket:

```elixir
defmodule Web.Tcp.Client do
  require Logger
  require Poison

  alias Web.Pubsub

  def start_link(token) do
    GenServer.start_link(__MODULE__, token, name: String.to_atom(token))
  end

  def init(token) do
    Pubsub.subscribe("#{token}:vars:callback")
    {:ok, %{token: token, messages: []}}
  end

  def handle_info(%{vars: vars}, %{token: token, messages: messages} = state) do
    Logger.debug("[tcp.client] received message: #{inspect(vars)}")
    message = _pack(token, "vars", vars)
    Logger.debug("[tcp.client] packed message: #{inspect(message)}")

    messages = messages ++ [message]

    Logger.debug("[tcp.client] begin send message: #{inspect(messages)}")
    state = token |> _get_socket |> _send_back(messages, state)
    Logger.debug("[tcp.client] done send message: #{inspect(messages)}")

    Logger.debug("[tcp.client] messages: #{inspect(messages)}")

    {:noreply, state}
  end

  def terminate(reason, status) do
    Logger.debug("[tcp.client] reason: #{inspect(reason)}, status: #{inspect(status)}")
    :ok
  end

  defp _send_back({:ok, socket}, messages, state) do
    :ok = _send(socket, messages)
    %{state | messages: []}
  end
  defp _send_back(:enqueue, messages, state) do
    %{state | messages: messages}
  end

  defp _send(s, []), do: :ok
  defp _send({socket, transport} = s, [message | messages]) do
    transport.send(socket, message)
    _send(s, messages)
  end

  def _pack(token, "vars", vars) do
    vars = vars
    |> Poison.encode!
    |> Base.encode64

    "v:#{token}:#{vars}\n"
  end

  defp _get_socket(token) do
    Logger.debug("[tcp.socket] search for socket, transport by token: #{inspect(token)}")
    response = case Registry.lookup(Registry.Sockets, token) do
      [{_, socket}] -> {:ok, socket}
      [] -> :enqueue
    end
    Logger.debug("[tcp.client] _get_socket: #{inspect(response)}")
    response
  end
end
```

## TCP Handler

The TCP handler registers the socket in the registry when it receives a connection and starts a new client worker to subscribe to the PubSub channel by API key, establishing communication between PubSub and the TCP client:

```elixir
defmodule Web.Tcp.Handler do
  require Logger

  alias Web.Pubsub

  @moduledoc """
  `Handler` waits for lines separated by \n (newline). If the handler doesn't
  see a newline, it accumulates data until it receives one.

  `Registry.Sockets` contains api_key -> socket records for easy communication
  from the dashboard page to TCP clients.
  """

  def start_link(ref, socket, transport, opts) do
    pid = spawn_link(__MODULE__, :init, [ref, socket, transport, opts])
    {:ok, pid}
  end

  def init(ref, socket, transport, _opts = []) do
    :ok = :ranch.accept_ack(ref)

    case transport.peername(socket) do
      {:ok, _peer} -> loop(socket, transport, "")
      {:error, reason} -> Logger.error("[tcp.handler] init receive error reason: #{inspect(reason)}")
    end
  end

  @timeout 5_000

  def loop(socket, transport, acc) do
    # Don't flood messages of transport, receive once and leave the remaining
    # data in socket until we run recv again.
    transport.setopts(socket, [active: :once])

    # Before proceeding with the receive block on messages, we should call
    # transport.messages() once to ping ranch
    {ok, closed, error} = transport.messages()

    receive do
      {ok, socket, data} ->
        Logger.debug("[tcp.handler] received data: #{inspect(data)}")

        acc <> data
        |> String.split("\n")
        |> Enum.map(&(String.trim(&1)))
        |> _process(socket, transport)

        loop(socket, transport, "")
      {closed, socket} ->
        Logger.debug("[tcp.handler] closed socket: #{inspect(socket)}")
      {error, socket, reason} ->
        Logger.error("[tcp.handler] socket: #{inspect(socket)}, closed because of error reason: #{inspect(reason)}")
      {:error, error} ->
        Logger.error("[tcp.handler] error: #{inspect(error)}")
      {'EXIT', parent, reason} ->
        Logger.error("[tcp.handler] exit parent reason: #{inspect(reason)}")
        Process.exit(self(), :kill)
      message ->
        Logger.debug("[tcp.handler] message on receive block: #{inspect(message)}")
    end
  end

  defp _kill(), do: Process.exit(self(), :kill)

  defp _process([], socket, transport), do: loop(socket, transport, "")
  defp _process([""], socket, transport), do: loop(socket, transport, "")
  defp _process([line, ""], socket, transport) do
    _protocol(line, socket, transport)
    loop(socket, transport, "")
  end
  defp _process([line], socket, transport), do: loop(socket, transport, line)
  defp _process([line | lines], socket, transport) do
    _protocol(line, socket, transport)
    _process(lines, socket, transport)
  end

  defp _protocol(line, socket, transport) do
    Logger.debug("[_protocol] line: #{line}")

    case line |> Web.Tcp.Protocol.process do
      {:verified, api_key} ->
        _register_socket(api_key, socket, transport)

        Web.Tcp.ClientSupervisor.start_client(api_key)

        Logger.debug("[tcp.server] transport should respond with OK")

        case transport.send(socket, "OK\n") do
          {:error, reason} ->
            Logger.error(inspect(reason))
          _ ->
        end
      {:error, reason} ->
        Logger.error("[tcp] #{inspect(reason)}")
      :error ->
        Logger.error("error on processing: #{inspect(line)}")
      _ ->
    end
  end

  def _register_socket(api_key, socket, transport) do
    Logger.debug("[tcp.handler] _register_socket token: #{api_key}")

    case Registry.register(Registry.Sockets, api_key, {socket, transport}) do
      {:error, {:already_registered, _pid}} ->
        Registry.update_value(Registry.Sockets, api_key, fn (_) -> {socket, transport} end)
      {:error, reason} ->
        Logger.error("[tcp] reason: #{inspect(reason)}")
      _ ->
    end
  end
end
```

## Protocol Handler

`Web.Tcp.Protocol` defines the parser and handler for commands passed via the TCP client:

Example commands:
```
l:logs:<base64 json messages>
i:vars:<base64 json variables>
v:api_key - client should pass api key to verify that we have a registered client
```

```elixir
defmodule Web.Tcp.Protocol do
  require Logger
  require Poison

  alias Web.Gateway
  alias Web.Db.Users

  @moduledoc """
    Server messages:

      - `l:logs`
        logs - should come as json array and encoded base64

      - `i:vars`
        vars - should come as json dictionary and encoded by base64

      - `v:api_key`
        api_key - should verify key using our registry

    Client messages:
      - `i:s:name:value` - var set by name value inside of app
  """
  def process("l:" <> <<api_key :: bytes-size(12)>> <> ":" <> logs) do
    Logger.debug("[protocol] api_key: #{api_key}, logs: #{inspect(logs)}")
    logs
    |> Base.decode64!
    |> Poison.decode!
    |> Gateway.logs(api_key)
  end

  def process("i:" <> <<api_key :: bytes-size(12)>> <> ":" <> vars) do
    Logger.debug("[protocol] api_key: #{api_key}, vars: #{inspect(vars)}")
    vars
    |> Base.decode64!
    |> Poison.decode!
    |> Gateway.vars(api_key)
  end

  def process("v:" <> <<api_key :: bytes-size(12)>>) do
    if Users.verify_key(api_key) do
      {:verified, api_key}
    else
      {:error, "not registered user with api_key: #{api_key}"}
    end
  end

  def process(_), do: :error
end
```

## Test Cases

Finally, here's a test case to review the basic expected behavior [tcp_test.ex](https://github.com/observerio/observer-server/blob/master/test/tcp_test.exs):

```elixir
defmodule Web.TcpTest do
  use ExUnit.Case
  doctest Web.Tcp

  alias Web.Db.Users

  require RedisPoolex
  require Logger
  require Poison
  require Tirexs.Query

  alias RedisPoolex, as: Redis

  setup do
    Redis.query(["FLUSHDB"])

    {:ok, api_key} = Users.register(%{email: "user1@example.com", password: "12345678"})

    port = Application.get_env(:web, :tcp_port)
    host = "127.0.0.1" |> String.to_char_list

    {:ok, socket} = :gen_tcp.connect(host, port, [active: false])
    {:ok, socket: socket, api_key: api_key}
  end

  test "should register user session", %{socket: socket, api_key: api_key} do
    :ok = :gen_tcp.send(socket, "v:" <> api_key <> "\n")
    {:ok, reply} = :gen_tcp.recv(socket, 0, 1000)
    assert reply == 'OK'
  end

  test "should bulk insert logs on tcp request", %{socket: socket, api_key: api_key} do
    :ok = :gen_tcp.send(socket, "v:" <> api_key <> "\n")
    :ok = :gen_tcp.send(socket, "l:" <> api_key <> ":" <> ([%{message: "testing1", timestamp: 123123123}, %{message: "testing2", timestamp: 123123123}] |> Poison.encode! |> Base.encode64) <> "\n")

    :timer.sleep(2000)

    assert {:ok, 200, %{hits: %{hits: hits}} = response} = Tirexs.Query.create_resource([index: "logs-#{api_key}", search: ""])
    assert Enum.count(hits) == 2
  end

  # TODO: add marker support to create separate sessions on multiple devices.
  # we could have separate dashboards for the different devices.
  test "should store vars on tcp request", %{socket: socket, api_key: api_key} do
    :ok = :gen_tcp.send(socket, "v:" <> api_key <> "\n")
    :ok = :gen_tcp.send(socket, "i:" <> api_key <> ":" <> ([%{name: "testing1", type: "string", value: "example"}, %{name: "testing2", type: "integer", value: "-1"}] |> Poison.encode! |> Base.encode64) <> "\n")

    :timer.sleep(2000)

    vars = Redis.query ["HKEYS", "#{api_key}:vs"]
    assert Enum.count(vars) == 4
    assert vars == ["testing1:type", "testing1:value", "testing2:type", "testing2:value"]
  end
end
```

In future posts, I'll share the modules for PubSub and Gateway implementation, which should be straightforward to understand.

This project was created for fun, so if you plan to use similar approaches in production, please proceed with caution. I don't work with Elixir daily, so there might be areas for improvement in this implementation.

Thanks for reading!


Engineering Blog