Improving Development Efficiency at Meiya: Practices, Tools, and Architecture

Meiya, like many early‑stage products, faces three common characteristics: a relatively small user base, rapid requirement changes, and an incomplete team.

1. Small user base. Occasionally there are exceptions, such as a viral growth case, but generally products do not have that luck.

2. Rapid requirement changes. Start‑up products contain many uncertainties; they cannot perfect every detail or fully implement features in a short time, so they usually push to market quickly to validate ideas.

3. Incomplete team. Internet start‑ups have a strong demand for engineers while the market supply is insufficient; they cannot afford high salaries, so team members often wear multiple hats.

Faced with this situation, Meiya focuses more on development efficiency than code execution speed or API response time. Development efficiency is affected by three aspects: communication cost (mainly between front‑end and back‑end), duplicate effort (re‑implementing existing open‑source solutions), and over‑design.

Communication Cost: Protocol / Process

1. Protocol

Many projects design front‑end/back‑end interaction protocols casually, e.g., /Post/Show/xx, without a unified standard.

Because the request does not clearly indicate how to fetch data, the client must ask the server or rely on documentation. For example, deleting a post could use DELETE or GET, with no standard; Meiya chooses a REST style.

REST (Representational State Transfer) operates on resources such as posts and comments. Meiya designs client request interfaces to operate on a resource, using the four HTTP verbs: GET, POST, DELETE, PUT. Example for user posts:

GET /posts – retrieve post list

GET /posts/id – retrieve a specific post

POST /posts – create a post

DELETE /posts/id – delete a post

PUT /posts/id – update a post

All new features, such as comments or likes, follow this standard, avoiding extra interface agreements.

In the client, the Post model maps directly to the backend fields, eliminating the need for separate documentation; a generated database dictionary resolves everything.

2. Process

Early development processes are imperfect, leading to issues like arbitrary releases of new code or bug fixes.

Meiya defines four stages: local, development, pre‑release, and production environments. After local work, code is submitted and automatically published to the integration environment; the pre‑release environment allows final verification before updating the user environment.

Code management uses long‑living branches master (main) and dev (integration). Feature or bug branches are merged into dev, then into master for release. Before pushing to pre‑release, code is reviewed, merged, and a git‑hook updates the pre‑release environment; the app switches environments via internal flags.

All team members see these activities via Slack, which subscribes to GitHub events. An exception reporting component (Fabric) sends client crashes to Slack, providing real‑time visibility.

Duplicate Effort: Framework / Library / Open‑Source Software

Framework

To ensure development efficiency, the framework must be simple for new members and powerful enough to reduce work. ORM is useful for small data but should be abandoned as scale grows. Meiya uses a PHP framework and tools (illustrated in the image).

DB Migration

DB migration tools express schema changes in code, allowing version‑controlled, environment‑consistent updates.

Command

Command‑line tools wrap input parameters, options, and output, reducing boilerplate beyond business logic.

Queue

Asynchronous queues handle tasks like push notifications, preventing synchronous blocking.

Tinker

An interactive CLI loads the whole project environment, enabling quick object queries without manual URL fiddling.

Log Handling

Configurable log levels allow selective logging per environment.

These components are not complex individually, but integrating them saves considerable development effort for a resource‑limited start‑up.

On the iOS side, Mantle handles model encoding/decoding, while TMCache and AFNetworking provide caching and networking, forming the complete model layer.

Meiya also adopts the ELK stack (Elasticsearch, Logstash, Kibana) for log processing and operational analytics, enabling real‑time monitoring of errors, performance, and business metrics.

Logs are collected by Logstash, stored in Elasticsearch, and visualized via Kibana; the same pipeline supports operational data analysis such as registration counts, regional distribution, and active user times.

The overall architecture: users interact with the app or PC, Nginx forwards requests to the API, logs are written to files, Logstash agents translate them to a fixed format for Elasticsearch, while the API also pushes logs to a message queue for asynchronous processing; dashboards query Kibana to present the data.

Managing Online Servers as a Developer Is Good Ops

Meiya’s ops team also develops; they use SaltStack with YAML to describe server states, enabling version‑controlled configuration. A simple SaltStack example shows a Logstash configuration, with a master node and multiple minion nodes. Updating all minions is done with a single command specifying a group (e.g., five servers) and the production environment.