Building an Effective Frontend Team in a Startup

Preface

After a long period of busy work and life, I finally have three days off to share and discuss frontend team topics with fellow developers. Regardless of industry, anyone in the working class experiences a progression: entering a team and keeping pace, becoming a more important member with responsibility and skill growth, and eventually leading newcomers or the whole team.

This article explores ways for traditional or startup frontend teams to become more professional, coordinated, and productive.

What Is a Startup Company?

A startup, in my view, is a business that is transitioning to the internet, investing in its own internet ecosystem, or pursuing a specific internet direction with limited funding and lower salaries compared to large internet giants.

Unlike large enterprises that focus on high‑end technology and architecture, startups prioritize rapid implementation, efficiency, and low cost. Their frontend teams often face scarce resources, tight deadlines, and the need to experiment and seek community solutions.

In a large company the frontend may be a small cog on a battleship; in a startup the frontend is like a pair of oars on a small boat—essential for moving forward.

Frontend Pain Points in Startups

Below are my personal observations.

1. Low Voice

Frontends were once called “slice‑and‑dice” workers, responsible only for cutting images and writing styles. Although the role has grown, many startups still give frontend engineers little say in architecture, reviews, or interaction decisions, leaving them with limited space to apply their experience.

2. Weak Underlying Infrastructure

When asked how to achieve project engineering, many developers simply reach for a scaffold like Vue‑CLI or Umi, without building a solid foundation. Startups often lack a component library, shared utilities, or consistent coding standards, focusing instead on delivering business code quickly.

3. Chaotic Collaboration

In larger companies, clear pipelines and responsibility matrices exist for design changes, approvals, and impact assessments. Startups usually rely on verbal agreements, resulting in duplicated questions, forgotten parameters, and inconsistent documentation.

4. Weak Team Cohesion

Team members tend to work in isolation, leading to divergent coding styles (different naming conventions, CSS naming, etc.) and a lack of shared ownership.

How to Break Through

Below are practical suggestions based on my experience.

1. Coding Standards

Establish clear module boundaries, naming conventions, and folder structures so that anyone can understand the code. If no senior engineer is available, adopt conventions from well‑known open‑source projects (e.g., Egg framework) and enforce them with tools like ESLint, TSLint, or Git hooks. Use IDE auto‑formatters such as WebStorm, IntelliJ IDEA, or VSCode with Prettier for consistency.

2. Design Standards

Even though design seems like a UI issue, frontend teams must define a shared design system to avoid endless pixel‑perfect adjustments. Create a base SCSS/LESS library and agree on a limited set of font sizes (e.g., 10 px, 14 px, 18 px, 22 px) to ensure consistency.

Example of defining a font map:

$font: zip(small normal large title, 10 14, 18, 22);

All components can then reference $font for uniform sizing.

3. Team Style

Document shared APIs and component usage using tools like VuePress or React‑Markdown. Encourage reusable templates and VSCode code‑snippets to keep code style uniform across the team.

4. Collaboration Documentation

Maintain internal documentation for component libraries, public APIs, and workflow diagrams. Tools such as ProcessOn or vscode‑drawio can help create quick visualizations of complex logic.

5. Project Infrastructure

While large enterprises may have extensive micro‑service and CI/CD setups, startups can start with simple scaffolds, local package registries, and shared component libraries to reduce duplication across multiple projects.

6. Collaboration Process

Adopt third‑party workflow tools (Tapd, Teambition, ZenTao) and API documentation platforms (Swagger, EasyAPI, YAPI) to replace verbal hand‑offs with written, traceable processes.

7. Department Building

Avoiding Turnover Gaps

Encourage cross‑project involvement so that when a team member leaves, knowledge is not lost.

Regular Retrospectives

Hold “complaint sessions” to share experiences, learn from each other, and refine processes.

Fostering Atmosphere

Organize technical talks and encourage blogging to boost team morale, even if time is limited.

8. Testing Standards

As projects grow, shared utilities increase. Use built‑in testing frameworks (Vue Test Utils, React Testing Library) to ensure changes do not break existing functionality.

Conclusion

Frontend teams in startups face many challenges, but by establishing coding and design standards, building documentation, improving infrastructure, and nurturing a collaborative culture, they can become more professional, coordinated, and productive. Feel free to share your thoughts and experiences.