Our team recently built an on-premises system that collects real-time data from more than 150,000 small and mid-sized renewable power plants across the country, and uses this data for power generation forecasting and monitoring. While cloud environments are the industry norm today, designing a large-scale system on-premises was a significant challenge for us due to our client’s strict security policies and data ownership requirements.

Challenges We Needed to Solve

The goals of the project were distilled into two core priorities: stability and scalability.

1. Reliable Data Ingestion: The 150,000 RTUs (Remote Terminal Units) use different communication networks and protocols such as LoRa, NB-IoT, and HTTPS. We needed to integrate all of them into a single system and ensure zero data loss during ingestion.

   
   

2. Real-time Processing and Scale-Out: The collected data needed to be processed immediately, and all components had to be designed with horizontal scalability in mind to flexibly handle future increases in the number of power plants.

   
   

3. Advanced Analytics Capabilities: Beyond simple data collection, we needed anomaly detection features that combine external weather data with power generation forecasts and comparisons against actual measurements.

   
   

4. Security and High Availability (HA): A high-availability architecture was essential to defend against external attacks and ensure continuous service even if some servers failed.

Technology Stack Selection – Why We Chose These Technologies

<Why We Chose a Reactive Stack>

When handling large-scale IoT data, the first challenge we considered was concurrency. While the traditional servlet-based Spring MVC is a well-proven technology, its thread-based model clearly has limitations for handling connections from 150,000 sites simultaneously.

Therefore, we chose Spring WebFlux. Operating in an asynchronous, non-blocking manner, WebFlux can handle a large number of concurrent connections with a small number of threads.

There were three decisive reasons for choosing WebFlux:

First, its event-loop model allows high concurrency, handling tens of thousands of connections simultaneously.

Second, it supports backpressure through Reactor’s Flux/Mono, automatically balancing speed differences between data producers and consumers.

Third, it offers memory efficiency, operating with fewer resources than a thread-based model.

<Event Processing with Kafka>

Introducing Apache Kafka was one of the most important architectural decisions in this project. We chose Kafka to reliably handle the simultaneous influx of data from 150,000 sites.
Kafka served more than just a simple message queue. It buffered sudden traffic spikes and decoupled the collection system from the processing system, allowing each component to scale independently and respond to failures.

Topic design was carefully planned. Topics were separated by protocol (IoT Platform A, B, C, HTTPS) to allow independent management according to each channel’s characteristics. Each topic consisted of six partitions for parallel processing, and a replication factor of three ensured data safety in case of broker failures. Messages were retained for seven days, providing sufficient recovery time in the event of unexpected issues.

Architecture Design – Data Flow

With the technology stack decided, the next step was figuring out how to combine them. We designed the system into four main areas, following the flow of data.

1. Data Collection Area

This is the entry point for data sent from RTU devices scattered across power plants nationwide. The data passes through firewalls and L4 switches before reaching the collection servers, where it is processed by protocol and published to Kafka.

<Data Collector>

An asynchronous server based on Spring WebFlux, converting various IoT protocols into a standardized internal format.
Non-blocking message publishing is implemented using reactor-kafka, and Reactor’s backpressure feature regulates the load sent to the Kafka cluster. It is container-based, allowing immediate scaling in response to increased traffic.

<Two-Layer Load Balancing: L4 Switch, Nginx, Docker>

In an on-premises environment without cloud-managed load balancers, we achieved high availability and scalability by layering hardware L4 switches and software load balancers for flexible traffic distribution.

Incoming traffic is first distributed to multiple servers by the L4 switch, and within each server, Nginx distributes requests to collection server instances packaged as Docker containers. The hardware switch handles fast network-level distribution and health checks, while Nginx manages detailed application-level routing.

Nginx uses a Least Connections algorithm, directing requests to the instance with the fewest active connections and automatically excluding failed instances through passive health checks.

upstream collector_api_server1 {
    least_conn;
    server collector-api-1:8081 max_fails=3 fail_timeout=30s;
    server collector-api-2:8081 max_fails=3 fail_timeout

2. Event Hub Area

Although Kafka topic design may seem simple, it requires careful consideration. We separated topics by protocol to isolate channels from affecting each other while ensuring scalability through partitioning.

Topic naming followed a consistent convention: {namespace}.collector.{platform}.raw-data, with all topic names centrally managed as constants in the Event Contracts module.

Partitioning strategy was also crucial. Each topic was divided into six partitions to enable parallel processing by consumers. Partition rebalancing ensures automatic load redistribution when consumers are added or removed.

3. Data Relay and Storage Area

The data accumulated in Kafka had to be safely transferred to the internal database. For security, we placed a relay server in the DMZ to consume Kafka messages and store them in the internal DB.The consumer module consumes Kafka messages and stores them in the database. Our first focus was optimizing batch processing. Messages were not processed individually but batched for DB storage: up to 1,000 messages per batch, or processed when at least 1MB of data was accumulated or 3 seconds had passed. This greatly improved DB insert performance.

To maximize throughput, we actively utilized consumer groups. Six consumers processed six partitions in parallel, each handling messages independently.

Retry and error handling were also important for stability. Temporary errors were retried up to three times at one-second intervals. If batch storage failed, fallback to individual inserts was used to preserve as much data as possible. Data that still failed was stored in a separate error table for future analysis.

4. Power Generation Forecasting and Analysis Area

Simply storing data alone does not create value. The analysis and forecasting server analyzes and predicts based on the collected data.

The forecasting server uses Dagster-based workflow orchestration. Dagster manages the scheduling and execution of the data pipeline, integrating data collection, preprocessing, and forecast execution into a single workflow. Pipeline execution history and dependencies are systematically managed.

Integration with external data was essential to improve prediction accuracy. The Python analysis pipeline collects weather forecast data via NOAA NWP (Numerical Weather Prediction model) to capture weather factors affecting solar power generation.

The power generation forecasting model combines historical generation data with weather data to predict future output, and the results are stored in the database for analysis and reporting.

5. Web Service Provision Area

This area provides web services where users can monitor power plant status and control the system.

The web service is built on a typical 3-tier architecture. The front-end WEB layer handles static resource serving and SSL/TLS termination, and load balances across two servers via L4 switches. Incoming requests are proxied to the WAS servers.

The WAS layer consists of three application servers to ensure high availability. The Business API Service running here is a Spring Boot-based RESTful API server that handles the core business logic of the monitoring service. Continuous uptime was a mandatory requirement. The database is duplicated using an Oracle RAC Active-Active cluster, all layers operate at least two servers, and L4 load balancing is configured. Thanks to the Docker-based setup, the system can recover quickly in the event of a failure.

The batch layer uses Spring Batch to perform large-scale data processing tasks, such as periodic statistics aggregation and report generation.

Collection Server Cluster Performance Validation

To validate the architecture under large-scale traffic conditions, we conducted rigorous load testing. Assuming 150,000 devices send data evenly over 60 seconds, the required throughput would be about 2,500 TPS.

150,000 Requests / 60 Seconds = 2,500 TPS

However, in reality, devices are not perfectly distributed. Traffic spikes often occur when many devices transmit simultaneously. Without client-side throttling, the server may need to handle sudden traffic exceeding 10,000 TPS. We aimed to secure approximately 4–5 times the average capacity to handle such traffic surges.

Load testing with Grafana k6 confirmed that a single node could process 3,000 collection requests per second (3,000 TPS) and the entire cluster could handle 12,000 requests per second (12,000 TPS) without delay. The non-blocking architecture of Spring WebFlux, Kafka’s traffic buffering, and the consumer’s batch insert strategy worked synergistically, ensuring stable processing without data loss even under load exceeding theoretical peak throughput.

Retrospective – Lessons Learned

<Advantages of Asynchronous Non-Blocking>

Applying Spring WebFlux in practice allowed us to experience the benefits of reactive programming in a large-scale IoT environment.
We achieved high throughput with minimal resources and ensured overall system stability through backpressure control.

<Kafka is More Than a Message Queue>

Through Kafka, we realized the true value of an event streaming platform.
Beyond simple message delivery, it reduces coupling between systems, enables failure isolation, and retains data for reprocessing, significantly enhancing overall architectural stability.

<Scalability Must Be Considered from the Start>

By designing a horizontally scalable architecture, we could handle increased traffic simply by adding servers.
Container-based architecture and Kafka’s partitioning mechanism made this possible.

<Flexible Infrastructure is Possible Even On-Premises>

Even without the cloud, we achieved flexible load balancing by layering L4 switches and Nginx.
The key was clearly separating the roles of each layer and managing configurations as code.

Conclusion

Building a system to handle real-time data from 150,000 sites in an on-premises environment was no easy journey.
Instead of relying on the convenience of cloud-managed services, we had to personally decide and implement every step, from hardware selection and network segmentation to defining server roles and configuring redundancy.

However, we learned a lot in the process. Utilizing Spring WebFlux and Kafka to reliably handle large-scale traffic, as well as software load balancing with Nginx and Docker to create a flexible architecture, has become a major asset for our team.

We hope this article provides some guidance for engineers considering large-scale traffic handling in on-premises environments.

Have you ever heard of the SOLID principles?

Even if you’re new to software development, you’ve probably heard the name at least once. The SOLID principles are five software development guidelines in object-oriented design: SRP, OCP, LSP, ISP, and DIP.

• SRP (Single Responsibility Principle)

• OCP (Open Closed Principle)

• LSP (Liskov Substitution Principle)

• ISP (Interface Segregation Principle)

• DIP (Dependency Inversion Principle)

Following these principles helps you create better object-oriented designs.

For frontend developers, especially those using React, a common question arises:

“How can I apply object-oriented principles in function-based React?”

At 60Hz, we use React across various domains including admin tools, dashboards, and user-facing web services.

React enables fast and declarative development but can make it easy to overlook design principles like SOLID. When deadlines loom, developers often pack API calls, state management, business logic, and UI rendering into a single component with the mindset “make it work first, refactor later.” It may feel fast initially, but ‘later’ rarely comes, and the code grows increasingly complex. Eventually, adding new features becomes intimidating, leading to adding more code instead of modifying existing code, which compounds the problem.

During my early years as a junior developer, I often felt trapped by design principles. Whenever I tried to apply a principle to a project, I focused solely on following it strictly rather than understanding why it mattered. This made adhering to principles uncomfortable, and eventually, I began to deliberately distance myself from them. Writing code felt cumbersome and time-consuming, and often the results were unsatisfactory.

Ironically, avoiding principles led me back to them. Why? Because development principles encapsulate philosophies for creating good software. They are distilled insights from developers who came before us, capturing both problems and solutions. Even if the concrete guidelines don’t fit every situation, the underlying philosophy can apply to any software development context. Taking a step back allowed me to apply the right philosophy at the right time.

This article starts from that awareness and explores how to apply the first SOLID principle, SRP (Single Responsibility Principle), in React code.

Single Responsibility Principle (SRP)

The core of the Single Responsibility Principle (SRP) is simple: a module (class, function, component) should have only one responsibility. Here, “responsibility” means the reason for change. Robert C. Martin phrased it as: “A module should be responsible to one, and only one, actor.”

Why is this important? When multiple responsibilities are combined in a single module, changing one aspect can unintentionally affect others. If responsibilities are clearly separated, the impact of changes is minimized, and the code becomes much easier to understand and test.

SRP in Real Life

Let’s look at a real-world example. Cars are made up of components, each with its own responsibility. If the AC breaks, you repair the AC; if the brakes fail, you replace the brakes. Each component can be serviced independently, making maintenance straightforward.

Now imagine the AC, brakes, and engine were merged into a single module. Replacing just the AC filter would require disassembling the entire module. You might accidentally touch the brake lines, causing brake fluid to leak, or miswire the engine, preventing it from starting. A simple AC fix could threaten critical functions like brakes or the engine. Naturally, repairs take longer and cost more.

Suppose a new AC component is developed. If the AC is separate, you can keep using the existing brakes and engine. But if the modules are combined, using the new AC would require creating a new module that combines the new AC, brakes, and engine, making the old module obsolete.

The same applies to software. Violating SRP leads to:

• High cost even for small changes (increased maintenance costs)

• Unexpected side effects when modifying code

• Fear of breaking existing code leads to adding new code instead of modifying, making code more complex

• Difficulty in reusing code (because multiple responsibilities are tangled)

Ultimately, SRP reduces maintenance costs and naturally improves reusability. In React, where components are frequently reused, adhering to SRP significantly enhances reusability.

Why SOLID Principles Are Easy to Miss in React Development

At 60Hz, we mainly use React for developing admin tools, dashboards, and user-facing web services. Because web development takes a large portion of our work, we actively use JavaScript and rely on React to enable declarative development that balances speed and maintainability. React is an excellent choice in many situations but also has characteristics that can lead developers to overlook SOLID principles.

JavaScript and React offer tremendous freedom. You can do anything inside a function, and a single component can contain both logic and UI. This freedom allows rapid feature implementation but also easily enables poor design. Languages like Java or C# enforce some design constraints through class structures and type systems, but in React, where everything is a "function," the boundaries of responsibility can become blurred.

When deadlines loom, developers often pack API calls, state management, business logic, and UI rendering into one component with the mindset, "make it work first, refactor later." It may feel fast initially, but that 'later' rarely comes, and the code becomes increasingly complex. Eventually, developers become hesitant to touch existing code, adding new code instead of modifying it, which compounds problems.

What ‘Responsibility’ Means in React Development

React development can ultimately be seen as function development. Business logic is implemented as functions, and even the UI is created using functions. What a function does is its responsibility. Therefore, in React, a responsibility includes not only “what business logic a function performs” but also “how and what UI it renders.”

Applying SRP in React

1. Separate Business Logic from UI

The first point to separate responsibilities is dividing business logic from the UI. In React, both business logic and UI are expressed as functions, so they are often combined.

// 책임이 섞여있는 컴포넌트
function MyProfile() {
  const [myInfo, setMyInfo] = useState(null);
  const [loading, setLoading] = useState(false);
  useEffect(() => {
    setLoading(true);
    fetch('/api/me')
      .then(res => res.json())
      .then(data => setMyInfo(data))
      .finally(() => setLoading(false));
  }, []);
  if (loading) return <Spinner />;
  return (
    <div className="profile">
      <img src={myInfo?.avatar} />
      <h1>{myInfo?.name}</h1>
      <p>{myInfo?.email}</p>
    </div>
  );
}

For example, consider a MyProfile component. At first glance, it may seem like a single-responsibility component that simply displays your information. However, it tightly couples two responsibilities: “fetching my information” and “rendering the profile UI.”

What problems does this create?

The most immediate issue is reduced reusability. Suppose another screen needs the same UI but for a different user. Since MyProfile is tied to your information, it cannot be reused. You would have to create a new component.

function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(false);
  useEffect(() => {
    setLoading(true);
    fetch(`/api/user/${userId}`)
      .then(res => res.json())
      .then(data => setUser(data))
      .finally(() => setLoading(false));
  }, [userId]);
  if (loading) return <Spinner />;
  return (
    <div className="profile">
      <img src={user?.avatar} />
      <h1>{user?.name}</h1>
      <p>{user?.email}</p>
    </div>
  );
}

Analyzing the component, we can see that the logic for fetching user information and the profile UI rendering logic are tightly coupled. Did you notice something odd? The same "profile UI rendering" responsibility exists in two components. And it’s not just two. Every time the same UI needs to be used elsewhere, a new component must be created, and we have no way of knowing how many more will be needed in the future.

This inevitably leads to maintenance issues. Even a simple change, such as "show '-' if the email is missing in the profile UI," requires manually updating many components, with a high chance of missing some.

Conversely, if business logic is reused in other components, the same code must be rewritten each time.

While coupling business logic and UI may seem natural at first glance, it is important to understand that it actually combines different responsibilities.

So, how should we fix this? As mentioned earlier, we can separate business logic from UI. Business logic can be placed in a Custom Hook, and UI can be handled by a separate component.

// 내 정보를 가져오는 책임 담당
function useMyInfo() {
  const [myInfo, setMyInfo] = useState(null);
  const [loading, setLoading] = useState(false);
  
  useEffect(() => {
    setLoading(true);
    fetch('/api/me')
      .then(res => res.json())
      .then(data => setMyInfo(data))
      .finally(() => setLoading(false));
  }, []);
  
  return { myInfo, loading };
}

// 유저 정보를 가져오는 책임 담당
function useUser(userId) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(false);
  
  useEffect(() => {
    if (!userId) return;
    
    setLoading(true);
    fetch(`/api/user/${userId}`)
      .then(res => res.json())
      .then(data => setUser(data))
      .finally(() => setLoading(false));
  }, [userId]);
  
  return { user, loading };
}

// UI를 렌더링하는 책임 담당
function ProfileCard({ avatar, name, email, loading }) {
  if (loading) return <Spinner />;
  
  return (
    <div className="profile">
      <img src={avatar} alt={name} />
      <h1>{name}</h1>
      <p>{email || "-"}</p> // 수정사항 반영
    </div>
  );
}

Now that we have separated responsibilities, let’s use the completed functions.

function MyProfile(){
  const { myInfo, loading } = useMyInfo();

  return (
    <ProfileCard
      loading={loading} 
      avatar={myInfo?.avatar} 
      name={myInfo?.name} 
      email={myInfo?.email}
    />
  )
}

function UserProfile({ userId }){
  const { user, loading } = useUser(userId);

  return (
    <ProfileCard
      loading={loading} 
      avatar={user?.avatar} 
      name={user?.name} 
      email={user?.email}
    />
  )
}

// 다른곳에서 비즈니스 로직 재사용
function Header(){
  const { myInfo, loading } = useMyInfo();

  return <UserSummary userLevel={myInfo?.level} name={myInfo?.name} />
}

How does it look? The ProfileCard component now has a single responsibility: responding only to changes in the UI. By separating business logic from UI in this way, several advantages emerge.

Improved Reusability

• ProfileCard can now be used anywhere.

• Need to display a profile on a new page? You can simply reuse the ProfileCard.

• If you need the business logic to fetch your information, you can reuse UseMyInfo.

Easier Maintenance

• UseMyInfo, UseUser: Responsibility for "how to fetch the data"

• ProfileCard: Responsibility for "how to display the profile"

• MyProfile, UserProfile: Responsibility for "how to combine which data with which UI"

• Each module has a clear single responsibility, so there is only one reason for any change. When performing maintenance, you can identify and modify only the relevant responsibility.

• 병렬 개발이 가능하다

  
  

  • API 서버 개발이 늦어지는 상황에서도 UI를 완성할 수 있고, 추후 비즈니스 로직 작성이 UI 컴포넌트를 수정하지 않습니다.

  • 반대로 디자인이 늦어지는 상황에서도 비즈니스 로직을 먼저 작성할 수 있습니다.

Parallel development is possible.

• Even if the API server development is delayed, the UI can be completed, and subsequent business logic development does not require modifications to the UI components.

• Conversely, if the design is delayed, the business logic can be developed first.

Each responsibility can be easily tested.

// Hook 테스트
test('useMyInfo는 내 정보를 가져온다', async () => {
  const { result } = renderHook(() => useMyInfo());
  await waitFor(() => {
    expect(result.current.myInfo).toBeDefined();
  });
});

// UI 테스트 (혹은 스토리북 테스트)
test('ProfileCard는 사용자 정보를 표시한다', () => {
  render(<ProfileCard avatar="/avatar.png" name="홍길동" email="hong@example.com" />);
  expect(screen.getByText('홍길동')).toBeInTheDocument();
});

2. UI Granularity

If business logic has been separated, the UI itself can also be divided into smaller responsibilities. Let’s take another look at the ProfileCard.

function ProfileCard({ avatar, name, email, loading }) {
  if (loading) return <Spinner />;
  
  return (
    <div className="profile">
      <img src={avatar} alt={name} />
      <h1>{name}</h1>
      <p>{email || '-'}</p>
    </div>
  );
}

This component appears to have a single responsibility: rendering the profile card. In some cases, this might indeed be a single responsibility. However, upon closer inspection, multiple UI elements may be mixed depending on the situation.

• Displaying avatar image

• Displaying user name

• Displaying email

• Structuring the overall layout

  
  

What if the following requirements arise?

• "Display user avatars and names in the comment section as well."

• "Show only the avatar in a circular shape in the header."

• "Make the email input field in the user edit form match the profile style."

With the current structure, reusing these small UI elements is difficult because multiple responsibilities are already mixed into the ProfileCard.

Just like business logic, UI components can also be split into smaller units of responsibility.

// 아바타 이미지 표시 책임
function Avatar({ src, alt, size = 'medium' }) {
  const sizeClasses = {
    small: 'w-8 h-8',
    medium: 'w-16 h-16',
    large: 'w-24 h-24'
  };
  
  return (
    <img 
      src={src} 
      alt={alt}
      className={`rounded-full ${sizeClasses[size]}`}
    />
  );
}

// 사용자 이름/이메일 표시 책임
function UserInfo({ name, email }) {
  return (
    <div className="user-info">
      <h3 className="text-xl font-semibold">{name}</h3>
      <p className="text-sm text-gray-600">{email || '-'}</p>
    </div>
  );
}

// 프로필 카드 레이아웃 구성 책임
function ProfileCard({ avatar, name, email, loading }) {
  if (loading) return <Spinner />;
  
  return (
    <div className="profile-card">
      <Avatar src={avatar} alt={name} size="large" />
      <UserInfo name={name} email={email} />
    </div>
  );
}

By breaking down the ProfileCard into individual responsibility units, each element can now be reused independently.

// 댓글 섹션 - 작은 아바타와 이름만
function Comment({ author, content }) {
  return (
    <div className="comment">
      <Avatar src={author.avatar} alt={author.name} size="small" />
      <div>
        <h4>{author.name}</h4>
        <p>{content}</p>
      </div>
    </div>
  );
}

// 헤더 - 아바타만
function Header() {
  const { myInfo } = useMyInfo();
  
  return (
    <header>
      <Logo />
      <Avatar src={myInfo?.avatar} alt={myInfo?.name} size="small" />
    </header>
  );
}

// 사용자 목록 - 아바타와 정보를 함께
function UserListItem({ user }) {
  return (
    <li className="flex items-center gap-3">
      <Avatar src={user.avatar} alt={user.name} size="medium" />
      <UserInfo name={user.name} email={user.email} />
    </li>
  );
}

Separating UI logic into responsibility units improves reusability and maintainability. A common pattern for this is the Atomic Design Pattern.

It’s important to note that not all UI elements need to be broken down into smaller components. The unit of responsibility varies by company and by developer’s perception. What matters is identifying and managing responsibility units based on what is actually reused and can be changed independently. There’s no need to compulsively break down every element.

3. Granularity of Business Logic

Separating business logic from UI is not the end. Business logic itself can also be divided into multiple responsibilities. If a Custom Hook handles multiple tasks at once, it also violates the Single Responsibility Principle.

For example, consider developing a shopping cart feature.

// 여러 책임이 섞여있는 Hook
function useCart() {
  const [items, setItems] = useState([]);
  const [loading, setLoading] = useState(false);
  
  // 장바구니 데이터 조회
  useEffect(() => {
    setLoading(true);
    fetch('/api/cart')
      .then(res => res.json())
      .then(data => setItems(data))
      .finally(() => setLoading(false));
  }, []);
  
  // 가격 계산
  const totalPrice = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  const discount = totalPrice >= 50000 ? totalPrice * 0.1 : 0;
  const shippingFee = totalPrice >= 30000 ? 0 : 3000;
  const finalPrice = totalPrice - discount + shippingFee;
  
  // 상품 추가/삭제
  const addItem = (product) => setItems(prev => [...prev, product]);
  const removeItem = (id) => setItems(prev => prev.filter(item => item.id !== id));
  
  return { items, loading, totalPrice, discount, finalPrice, addItem, removeItem };

This Hook has several responsibilities:

• Fetching cart data

• Calculating prices (total, discount, shipping)

• Managing cart items

What problems might arise?

If the order page only needs price calculation, using useCart will also fetch unnecessary cart data.
The price calculation code is a pure function without external dependencies, yet testing it requires API mocking.

How can we separate responsibilities?

// 가격 계산 로직만 담당
function calculatePrice(items) {
  const totalPrice = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
  const discount = totalPrice >= 50000 ? totalPrice * 0.1 : 0;
  const shippingFee = totalPrice >= 30000 ? 0 : 3000;
  const finalPrice = totalPrice - discount + shippingFee;
  
  return { totalPrice, discount, shippingFee, finalPrice };
}

// 장바구니 데이터 조회만 담당
function useCartData() {
  const [items, setItems] = useState([]);
  const [loading, setLoading] = useState(false);
  
  useEffect(() => {
    setLoading(true);
    fetch('/api/cart')
      .then(res => res.json())
      .then(data => setItems(data))
      .finally(() => setLoading(false));
  }, []);
  
  return { items, setItems, loading };
}

// 필요한 것들을 조합
function useCart() {
  const { items, setItems, loading } = useCartData();
  const priceInfo = calculatePrice(items);
  
  const addItem = (product) => setItems(prev => [...prev, product]);
  const removeItem = (id) => setItems(prev => prev.filter(item => item.id !== id));
  
  return { items, loading, ...priceInfo, addItem, removeItem };
}

By dividing the logic, each module can be assembled where needed and reused independently. Testing also becomes much easier.

// 주문 페이지 - 가격 계산만 재사용
function OrderSummary({ orderItems }) {
  const { totalPrice, discount, finalPrice } = calculatePrice(orderItems);
  
  return (
    <div>
      <p>총 금액: {totalPrice}원</p>
      <p>할인: -{discount}원</p>
      <p>최종 금액: {finalPrice}원</p>
    </div>
  );
}

// 장바구니 페이지 - 전체 기능 사용
function CartPage() {
  const { items, finalPrice, addItem, removeItem } = useCart();
  // ...
}

// 가격 계산 테스트
test('5만원 이상 구매시 10% 할인이 적용된다', () => {
  const items = [{ price: 50000, quantity: 1 }];
  const result = calculatePrice(items);
  expect(result.discount).toBe(5000);
});

By separating business logic into appropriate responsibility units, we increased reusability and made maintenance easier. Like UI logic, there is no need to force business logic into excessively small units. Start with reasonable responsibility units and separate further only when necessary.

The key point is: when you feel a separation is needed, you must perform it.

Conclusion

In conclusion, we looked at how the Single Responsibility Principle can be applied in React. Beyond the benefits mentioned, there’s another advantage to separating responsibilities.

When delegating tasks to AI, it often produces much better results if responsibilities are separated into units, compared to giving AI a component with multiple mixed responsibilities. This approach is also easier to manage from the perspective of AI-generated outputs.

The Single Responsibility Principle is not exclusive to object-oriented programming. SOLID principles and other development principles are philosophies that can be applied in React development—or any type of development. What matters is not blindly following principles, but understanding their underlying philosophy and applying it appropriately to the situation.

Are your components carrying too many responsibilities? Are they struggling, and is it difficult for the maintainers too? Taking a moment to reflect will be valuable.

Ultimately, good design does not come from blindly following principles—it begins with understanding them and applying them selectively.

Renewable energy has become an integral part of our daily lives. You can see small solar panels installed on rooftops of buildings and, when driving on highways, you may come across vast solar farms spread across hillsides. Near the seaside, you might notice tall wind turbines reaching towards the sky.

As the name suggests, renewable energy generation uses natural resources such as sunlight and wind to produce electricity. Even for those unfamiliar with how it works, it naturally feels like a clean and economical solution. In fact, once renewable energy facilities are installed, they require minimal additional generation costs and have very little environmental impact.

This sounds ideal — environmentally friendly electricity at a low cost. It seems like everyone should be using it, right? But are you, personally, using renewable energy? Are businesses using it extensively? While some individuals and companies do, most still do not.

Why is that? If renewable energy is so beneficial, why don’t we simply install enough to power the entire nation? The answer lies in one critical issue: uncertainty.

The Nature of Electricity and the Limits of Renewable Energy

Electricity has a unique characteristic — it is difficult to store and must be consumed at the exact moment it is produced. When you flip a light switch, the bulb lights up instantly. This means electricity is continuously generated, transmitted, and used in real time.

For a stable grid, production and consumption must always be in balance. In Korea, our power grid operates at a standard frequency of 60Hz — which is where our company name, 60Hertz, comes from.

• If production exceeds consumption, the frequency rises and can damage electrical equipment.

• If production falls short of consumption, blackouts may occur.
  
  

To maintain this delicate balance, KPX (Korea Power Exchange) constantly monitors and stabilizes the grid.


The Challenge with Renewable Energy

Renewable energy production depends entirely on nature.

• On cloudy days, solar power generation drops sharply.

• When there’s no wind, wind turbines cannot produce power.

• Conversely, on sunny or windy days, generation can surge unexpectedly.
  
  

This variability makes it difficult to rely solely on renewable energy, even at a single household level.

For example:

• Summer evenings: Air conditioning drives demand up around 6 PM, but solar generation decreases as the sun sets. This mismatch can cause supply shortages.

• Midday in spring: When consumption is low but solar generation is high, excess energy can overflow into the grid, potentially causing instability.
  
  

When renewable energy sources are scaled up and connected to the national grid, these fluctuations can become a serious risk to grid stability. This inherent intermittency and unpredictability is the biggest hurdle for renewable energy adoption.


ESS: The Heart of Renewable Energy

So, how do we overcome this challenge? The answer lies in ESS (Energy Storage System) — essentially a giant battery.

Just like charging your phone and using it later, an ESS stores electricity when supply is high and releases it when demand is high.

Example scenario:

• Noon on a summer day: Solar generation peaks while most people are away from home, so demand is low. The ESS stores the surplus electricity.

• Evening: People return home, turn on appliances, and demand spikes — just as solar generation drops. The ESS then discharges stored energy to meet demand.
  
  

ESS acts like the heart of a renewable energy system, pumping energy where it’s needed, when it’s needed. It smooths out fluctuations, making renewable power reliable and stable.


60Hertz: The Brain of Renewable Energy

While ESS plays a vital role, it is, at its core, just a battery — it charges and discharges.
This is where 60Hertz steps in as the "brain" of renewable energy.

We develop software that intelligently controls ESS to maximize efficiency and stability.
Our platform doesn’t just turn charging on and off — it makes data-driven decisions in real time.

Key Capabilities

• Storing Surplus Renewable Energy

  • We predict solar generation and household consumption.

  • Surplus energy is automatically stored in the ESS for later use.

  • This enables flexible, optimized renewable energy utilization.

• Time-of-Use Cost Optimization

  • In Korea, electricity rates vary by time of day (off-peak, mid-peak, peak).

  • Our algorithms charge ESS during cheaper off-peak hours and discharge during expensive peak hours.

  • When solar energy alone isn’t sufficient, the system can purchase extra power from the grid at off-peak prices to charge efficiently.

• Demand Response (DR) Participation

  • KPX sends signals to adjust electricity usage:

    • Reduce consumption when the grid is under strain (DR).

    • Increase consumption when there’s excess supply (Plus DR).

  • ESS is ideal for responding to these signals.
    
    

Our software enables seamless participation, providing financial incentives for users while supporting grid stability.


Electric Vehicles: Moving ESS Units

Why mention electric vehicles (EVs)? Because an EV is essentially a mobile ESS.

• EVs store large amounts of energy in their batteries.

• They can charge from the grid or discharge to the grid — a technology known as V2G (Vehicle-to-Grid).

• Many EVs already support V2L (Vehicle-to-Load) for powering external devices like camping gear or emergency equipment.
  
  

Unlike traditional ESS units, which are expensive and stationary, EVs are already widely available and distributed.

At 60Hertz, we are developing software that turns EVs into flexible, grid-connected energy resources, empowering individuals to participate in renewable energy ecosystems.

We believe EV owners will play a key role in grid stabilization and renewable energy adoption in the near future.


Building the Future Together

At 60Hertz, we are creating software solutions that seamlessly integrate renewable energy into daily life.

Our mission:

• Analyze the energy market and renewable ecosystem.

• Develop algorithms that adapt to complex conditions.

• Deliver intuitive, user-friendly services with clear visualizations.
  
  

If you are passionate about renewable energy, V2G technology, or want to help build the future of sustainable power, we invite you to follow our journey — and even join our team as a software engineer.

Together, we can transform the way the world generates, stores, and uses energy.


By Kyungmin Bang ㅣ TVPP/FE Leader ㅣ 60Hertz




#RenewableEnergy #EnergyStorage #ESS #DR #ElectricVehicle #V2G #SmartGrid #CarbonNeutral #EnergyTransition #EnergyInnovation #VirtualPowerPlant #SolarPower #WindPower #GridStability #SixyHertz #EnergySoftware

The energy IT social venture 60Hertz participated in the World Climate Industry Expo (WCE) 2025, held from August 27 to 29 at BEXCO in Busan. This global climate and energy exhibition was co-hosted by the Ministry of Trade, Industry and Energy (MOTIE), the International Energy Agency (IEA), and the World Bank (WB). Bringing together around 560 leading domestic and international companies, the event served as a stage for showcasing cutting-edge technologies driving the future of energy innovation.

WCE 2025 Theme: “Energy for AI & AI for Energy”

This year’s theme, “Energy for AI & AI for Energy,” explored how artificial intelligence can help build a sustainable, safe, and efficient global energy system. Key discussions centered on leveraging AI to address the rising demand for energy and enhance grid stability. The exhibition featured diverse sectors such as clean energy, energy & AI, future mobility, environment, ocean, and climate, alongside three major summits — Global Leadership, Energy & AI, and Climate — and 12 specialized conferences, creating a comprehensive platform for knowledge exchange and collaboration.

Exhibition Hall #1: Highlights

In Hall 1, leading Korean companies including SK, Hyundai Motor, Samsung Electronics, Hanwha Q Cells, Doosan Enerbility, POSCO, Hyosung Heavy Industries, and Korea Zinc showcased their latest solutions for the energy transition. Particularly notable were the dynamic exhibits focused on clean energy, smart grids, and the hydrogen economy, reflecting the industry’s commitment to grid innovation and achieving carbon neutrality. Visitors engaged directly with cutting-edge technologies, networking with industry representatives and experiencing first-hand the innovations driving Korea’s emergence as a global hub for the energy transition.

60Hertz Booth & Key Outcomes

At WCE 2025, 60Hertz participated in the Korea Energy Fair Innovation Awards Special Hall and the Korea Power Exchange (KPX) booth, introducing its AI-driven integrated energy management solutions. Over the course of three days, the booth attracted a wide range of stakeholders, including representatives from public institutions, large corporations, and financial organizations, all showing significant interest.

Key activities included:

• Exploring international renewable energy business collaborations

• Conducting in-depth consultations on energy monitoring and care solutions

• Discussing PPA outsourcing services and new service models

Building opportunities for follow-up partnerships across various sectors

CMV Project with KPX

60Hertz also introduced its Cloud Movement Vector (CMV) project, a joint initiative with KPX, at the exhibition. Through engaging graphics and video content, the company showcased its cloud movement-based ultra-short-term generation forecasting system, providing a fresh perspective on visualizing and managing renewable energy in power markets.

Innovation Award, IR, and Seminar Participation

During the event, 60Hertz was honored with the MOTIE Minister’s Award at the Climate-Energy Innovation Awards ceremony — a meaningful milestone that officially recognized the company’s technological excellence and contributions to the energy sector. In addition, 60Hertz participated in the IR corporate introduction session and a mini-seminar hosted by Korea Midland Power, where it shared its vision and solutions for renewable energy expansion and grid innovation.

Audience Reactions & Survey Insights

A survey conducted at the Innovation Awards Special Hall gathered 78 responses, primarily from professionals in manufacturing, energy & power, and public sectors.
Key areas of interest included:

• Energy savings and profitability improvements

• AI applications in energy management

• Partnership and collaboration opportunities

The feedback highlighted the strong market demand and enthusiasm for innovative renewable energy solutions.


The Impact of WCE 2025

By participating in WCE 2025, 60Hertz confirmed new opportunities for domestic and international collaboration, while reaffirming the market potential and necessity of its AI-powered energy innovation solutions. Moving forward, the company will continue to expand its global partnerships to drive the spread of renewable energy, enhance operational efficiency, and contribute to the realization of carbon neutrality. 60Hertz remains committed to building the infrastructure and solutions that will power the clean energy future.


#WCE2025 #60Hertz #RenewableEnergy #ClimateIndustryExpo #SmartGrid #CleanTech #NetZero #InnovationAward

60Hertz had the pleasure of participating in the 2nd Korea Social Value Festa, held from August 25 (Mon) to 26 (Tue) at COEX Hall C in Seoul, Korea. Over the course of two vibrant days, we connected with a wide range of organizations and companies, engaging in meaningful discussions on how we can collaborate to build a sustainable future.

What is the Korea Social Value Festa? 🎊

Hosted by the Korea Chamber of Commerce and Industry, and co-organized by SOVAC, SK Telecom, Hyundai Marine & Fire Insurance, Kakao Impact, KOICA, and others, the Korea Social Value Festa is the nation’s largest event dedicated to solving complex social challenges — from climate change and regional decline to generational divides and the digital gap — through public-private partnerships. This year’s Festa brought together over 13,000 visitors and 300 participating organizations and companies, featuring a wide variety of lectures and exhibitions under the theme: “Designing the Sustainable Future.”

60Hertz Exhibition Booth ☀️

At this year’s Festa, 60Hertz operated a booth within the “Path of Innovation – Overcoming the Climate Crisis” zone, where we showcased our AI-driven solutions for renewable energy forecasting and integrated energy resource management. Our technology enables the integration and optimization of diverse energy resources, supporting climate crisis response, stable power system operations, and the realization of carbon neutrality. Over the course of the two-day event, we had the opportunity to meet with public institutions, large corporations, social ventures, financial organizations, and industry experts. These interactions allowed us to share our vision and technology while also exploring new opportunities for collaboration.

“Challenge 60HZ!” Quiz Event 🎁

To make our booth experience more interactive, we hosted a fun “Challenge 60HZ!” quiz event for visitors. Through questions related to renewable energy and carbon neutrality, participants were able to engage with 60Hertz’s mission and solutions in a memorable way. Those who answered all questions correctly received special gifts, which created a lively and exciting atmosphere at our booth!

Building Connections for the Future 🤝

The Festa provided a unique platform for meaningful encounters with partners from both the public and private sectors, as well as fellow social ventures. Through these conversations, 60Hertz was able to expand our network and explore new opportunities for collaboration in renewable energy. We deeply appreciate the interest and support we received from everyone who visited our booth and shared our commitment to driving social value through renewable energy adoption. 🙏


Looking Ahead 🗓️

This Festa was more than just an exhibition. It was an invaluable opportunity for 60Hertz to reflect on our role as a leader in renewable energy and climate tech. We will continue to build on the relationships formed during this event, fostering partnerships that will enable more companies and institutions to join the transition to sustainable energy. Our commitment to innovation and collaboration remains stronger than ever.

In Closing

The Korea Social Value Festa, organized in collaboration with SOVAC, is a space where we can share the vision of “Creating a Sustainable Future Together.” 60Hertz is honored to be part of this journey and will continue to pursue technological innovation and social value creation to address the challenges of climate change.

A heartfelt thank you to everyone who joined us and supported our mission! 🌏💚


#60Hertz #SOVAC #SocialValueFesta #ClimateTech #RenewableEnergy #EnergyTransition #CarbonNeutrality #Sustainability #SocialImpact #GreenFuture

In recent news, the term “energy expressway” has been gaining attention, emerging as a key policy topic in energy transition discussions. At first glance, the phrase might evoke images of roads or transportation networks. However, it’s actually a metaphor for advanced transmission infrastructure designed to move electricity over long distances and at large scales, efficiently and reliably. In this post, we’ll explore what the “energy expressway” means and unpack some of the key concepts behind it.

Why Call It a “Expressway”?

Just as a highway allows people and goods to travel quickly and efficiently, an energy expressway enables electricity generated in one region to be “transported” swiftly and effectively to distant areas where demand is concentrated. It’s a fitting metaphor for a system designed to move massive amounts of renewable power across wide geographies.

Why Do We Need It?

The world is rapidly expanding its use of renewable energy to achieve carbon neutrality, but there’s a mismatch between where renewable power is generated and where it’s consumed.

• Solar farms are usually located on sunny rooftops, open fields, or industrial complexes far from city centers.

• Offshore and onshore wind farms thrive in coastal or mountainous areas with strong winds.

• Electricity demand, on the other hand, is heavily concentrated in urban areas, industrial hubs, and dense population centers.

This geographic imbalance creates a pressing need for infrastructure that can bridge the distance between production and consumption. The energy expressway is that bridge—a network designed to carry clean energy to where it’s most needed, overcoming location constraints and enabling a smoother, more resilient energy transition.

The Technology Behind It

Building an energy expressway requires more than simply extending existing power lines. The system must handle very high volumes of electricity over extremely long distances with minimal loss and maximum stability.

Key technologies include:

• HVDC (High-Voltage Direct Current) Transmission: Essential for reducing energy loss over long distances and transporting bulk power efficiently.

• Smart, digitalized grids: Using AI and IoT for real-time monitoring, demand forecasting, and dynamic control of distributed resources.

• Advanced substations and converters: To seamlessly switch between alternating current (AC) and direct current (DC).
  
  

Main Features

• Long-distance, high-capacity transmission: Delivering power from remote solar and wind farms to cities and industrial parks.

• Integration with smart grid technologies: Leveraging real-time data and automation for efficient energy distribution.

• Regional interconnection: Linking different areas to balance supply and demand, improving grid stability and resilience.

Economic and Environmental Benefits

The energy expressway brings significant value beyond just moving electrons.

• Economic efficiency: By sourcing power from regions with lower renewable generation costs, it helps stabilize electricity prices.

• Environmental impact: It accelerates the retirement of fossil-fuel plants, reducing carbon emissions and supporting national and global climate goals.

This makes the energy expressway a cornerstone of sustainable energy systems.

Challenges and Limitations

Despite its potential, developing an energy expressway is a complex and costly endeavor:

• High capital costs: Projects often require multi-billion-dollar investments for undersea cables, converter stations, and control systems.

• Long project timelines: From design and permitting to construction, projects can take years or even decades.

• Social and regulatory hurdles: Debates over electricity pricing, land use, and government subsidies are common.

• Technical and cybersecurity concerns: Operational reliability and protection against digital threats are critical.

These hurdles mean that while essential, building such infrastructure demands careful planning, collaboration, and innovation.

The Hidden Road of Innovation

Much like highways fueled industrial growth in the past, energy expressways will power the renewable revolution. They address fundamental challenges:

• Renewables located in rural or remote areas vs. concentrated demand in cities.

• The intermittent nature of solar and wind power vs. the need for stable, reliable electricity.

As nations, including South Korea, plan their energy futures, the question isn’t whether to build these invisible highways, but how to design and implement them effectively. The choices made today will shape the path to a cleaner, more resilient energy system for decades to come.

The energy expressway represents more than just infrastructure—it’s a strategic investment in our sustainable future, ensuring that renewable energy can flow freely, reliably, and equitably to every corner of society.


#EnergyExpressway #TransmissionNetwork #GridInnovation #CarbonNeutral #EnergyTransition #RenewableIntegration #PowerInfrastructure #HVDC #SmartGrid #DERIntegration #SmartEnergy #CleanEnergyTech

On May 14, the Financial Services Commission of Korea, in collaboration with 13 government ministries including the Ministry of Trade, Industry and Energy, the Ministry of Science and ICT, and the Ministry of SMEs and Startups, announced the selection of 509 small and medium-sized enterprises for the 2025 First Round of the Premier Innovation 1000 program.

This initiative aims to identify and support promising companies capable of driving technological innovation, launching new products and services, creating added value, and generating employment.

60Hertz’s selection is a formal recognition by the Korean government of the innovation and growth potential of our AI-based renewable energy forecasting and control technology. It also marks a significant milestone that affirms our technological capabilities and long-term vision for a sustainable energy transition.

Our core technologies include:

• Virtual Power Plant (VPP) integration software that manages distributed renewable energy resources

• AI-powered generation forecasting solutions that reduce uncertainty and enhance operational efficiency in power management

These innovations have played a key role in advancing the renewable energy ecosystem and were major factors in our selection for this honor.

As part of the program, 60Hertz will receive customized support from policy finance institutions and benefit from special opportunities across government-supported projects—accelerating our progress toward technology-driven energy transition and global market expansion.

[About 60Hertz]

In 2021, 60Hertz gained national attention by launching the “Korea Virtual Power Plant”, a platform that connects over 130,000 solar, wind, and energy storage systems (ESS) across the country. Since then, 60Hertz has continued to expand its data-driven energy services, including the release of the “Sun and Wind Map”, a free public platform that uses AI to visualize the locations and generation forecasts of approximately 80,000 renewable energy facilities totaling 18GW in capacity.

• 2023: Winner of a CES Innovation Award for our proprietary Energy Management System (EMS)

• 2024: Named one of the Top 100 Climate Tech Startups in Asia-Pacific by the Indo-Pacific Economic Framework (IPEF)

At 60Hertz, we remain committed to innovation that enables more people and communities to participate in a sustainable energy future.

👉 Visit our website


#60Hertz #Renewable #Energy #VPP #AI #RE100 #Innovation #Top1000

Hello,
This is 60Hertz, an energy IT social venture.

We would like to extend our sincere thanks to everyone who visited the 60Hertz booth at the 2025 ESG & Carbon Neutrality Expo for the Automotive Parts Industry, held from April 23 to 25 at aT Center in Yangjae-dong, Seoul.

At the expo, 60Hertz showcased a wide range of energy IT solutions designed to help companies achieve their sustainability goals.

Our key offerings included:

• Solar PV plant development and operation solutions

• Integrated energy monitoring system (EMS)

• V2G-based next-generation energy ecosystem development

• Demand Response (DR) solutions for efficient energy management

• On-site PPA and RE100 consulting services
  
  
  

We were especially encouraged by the strong interest shown in utilizing idle spaces—such as factory rooftops and parking lots—for solar energy, and we appreciated the in-depth conversations around reducing energy costs through renewable energy transition.

For example, installing a 1MW solar power plant on a 10,000㎡ (approx. 3,000 pyeong) factory rooftop can lead to:
✔ Annual electricity savings of around KRW 30 million
✔ Additional energy-related revenue
✔ Approximately 604 tons of CO₂ emissions reduced per year

With 60Hertz’s solutions, you can easily manage the entire renewable energy journey—from solar installation and real-time generation monitoring to RE100 performance tracking—all in one platform, empowering your ESG management.

60Hertz will continue to be a trusted partner in your path toward carbon neutrality and sustainable growth.

For further inquiries or consultations, feel free to contact us anytime.

We look forward to building a sustainable future together.

👉 Learn more about 60Hertz solutions

#60Hertz #ESG #RE100 #CarbonNeutrality #NetZero #V2G #DR #EMS #Solar #Renewable #Energy

Characteristics of Distributed Energy Resources

As carbon neutrality becomes a global priority, interest in distributed energy is rapidly growing. Distributed energy refers to energy produced near the point of consumption, offering an alternative to centralized power generation systems. These systems are typically small in scale and located close to the end users, reducing reliance on large power plants and long-distance transmission infrastructure.

Expansion of Distributed Energy Resources

Distributed energy systems are often more cost-effective than traditional power infrastructure, requiring fewer investments in large-scale transmission lines and substations. DERs also promote clean energy adoption, with solar and wind playing a central role in reducing carbon emissions.

However, the intermittent nature of solar and wind power—due to reliance on weather conditions—introduces variability. This can pose challenges for grid stability, especially in regions like South Korea where solar adoption is accelerating. As a result, there’s growing attention on technologies and policies that can help mitigate intermittency and improve efficiency.

Energy Scrum: A Smarter Way to Manage DERs

To meet the growing need for advanced DER control and forecasting, 60Hertz developed Energy Scrum, a next-generation Energy Management System (EMS) designed specifically for distributed energy. Energy Scrum uses AI-powered forecasting to manage and monitor diverse resources—including solar (PV), energy storage systems (ESS), fuel cells, and EV chargers—within a single, integrated platform.

Designed for Ease and Efficiency

Energy Scrum is designed to be user-friendly and scenario-based, allowing operators to apply customized strategies to meet their sustainability goals. For example, a user could apply it to an older gas station to transform it into a green energy station by optimizing solar and storage resource usage.

Powered by AI and Open Data

Energy Scrum integrates cloud-based AI models with large volumes of unstructured data from DERs, IoT sensors, and external sources such as weather satellites. These models continuously learn to produce accurate energy forecasts, helping users adapt their operations in real time. The system also supports multiple operation modes, such as maximizing renewable power usage, based on user preferences and targets.

Differentiated for a Growing Market

Unlike many existing monitoring tools, Energy Scrum is built to be highly customizable for a wide range of customers—including manufacturers—and supports a broad spectrum of DER types. It also goes beyond basic monitoring by offering a market-connected platform, helping power producers participate in energy trading and unlock new revenue streams.

One such example is Vehicle-to-Grid (V2G) integration, which allows EVs to supply unused power back to buildings or the grid—turning vehicles into mobile energy assets.

Recognized at CES 2023

Energy Scrum received a CES 2023 Innovation Award in the categories of Sustainability, Eco-Design, and Smart Energy. As clean distributed energy becomes more prominent globally, demand for unified, intelligent management systems is rising. Energy Scrum is paving the way for the next generation of renewable energy integration, offering total oversight of not just solar, but also wind and ESS infrastructure.

By optimizing and interconnecting these resources, Energy Scrum is helping to make clean energy more scalable, profitable, and impactful—one intelligent decision at a time.

#60Hertz #RenewableEnergy #EMS #VPP #ESS

As RE100 and carbon neutrality become the new standard for global businesses, technology that makes renewable energy easier and more efficient to use is no longer optional—it’s essential. 60Hertz, an energy IT social venture, is turning this transition into reality. By leveraging AI, big data, and cloud technologies, we help maximize the value of distributed renewable energy resources—creating measurable impact for both society and the environment.

Impact by the Numbers

In the past year, 60Hertz enabled 8 companies to collectively consume 11,901 MWh of renewable energy through our subscription-based service. This helped reduce approximately 5,089 tCO₂e of carbon emissions, marking meaningful progress toward corporate net-zero goals. We also supported social ventures and SMEs by facilitating small-scale REC purchases and offering transparent monthly reporting systems—making renewable energy more accessible and accountable for all.

Technology for Smarter Energy Transition

60Hertz builds and operates a suite of smart solutions that stabilize the energy grid even amidst fluctuations in weather, demand, and supply.

☀️ Sun & Wind Map

The only public renewable generation forecasting service in Korea. This AI-powered platform predicts and visualizes daily and next-day generation levels for solar and wind power plants nationwide, integrating real-time weather data and forecasted generation for strategic decision-making.

🔋 Energy Scrum

An integrated energy management system for distributed energy resources (DERs) such as solar plants, EV chargers, and energy storage systems (ESS). By using AI-driven forecasting and real-time optimization, Energy Scrum balances supply and demand dynamically. Its cloud-based architecture ensures scalability and security, and is plan to directly connect to Korea’s energy market infrastructure.

Social Value Meets Sustainability

60Hertz goes beyond technology—we are building a more sustainable business ecosystem.

• RE100 Corporate Support: Providing subscription-based access to renewable energy for companies with carbon neutrality targets.

• Support for Small Businesses: Helping early-stage ventures switch to 100% renewable energy, even with limited financial resources.

• Impact Measurement: Tracking both quantitative and qualitative outcomes through project-level performance analysis.

• Donated Solar Plants: Expanding clean energy access to vulnerable communities through rooftop solar projects.
  
  
  
  

Scaling Up for the Future

We are actively working on expanding our reach and deepening our impact with the following focus areas:

Global Platform Expansion - Bringing our proven technologies to the Asia-Pacific region by building infrastructure for cross-border renewable energy trading.

Enhanced RE100 Simulation Services - Developing customized simulation tools to help more companies plan and execute their renewable energy transitions.

V2G (Vehicle-to-Grid) Innovation - Integrating EVs as a dynamic part of the renewable energy network—unlocking new levels of flexibility and efficiency in distributed energy use.

The Journey Toward a Sustainable Energy Ecosystem

At 60Hertz, we’re more than a technology provider. We’re building the tools, partnerships, and platforms to accelerate the global transition to clean energy. Our goal? A future where every company—and every community—can be part of the solution to climate change.

#60HERTZ #SDC #RE100 #SOCIAL #IMPACT #ESG

A Team Creating Extraordinary Technology for Everyday Life

Maintaining a stable power grid is essential.

When the grid becomes unstable, it can lead to national-scale disasters such as blackouts. In Korea, the grid operates at a standard frequency of 60 hertz when power supply and demand are in perfect balance.

That’s why 60Hertz represents more than just a number — it symbolizes the balance that protects our daily lives.

At 60Hertz, we create technologies that safeguard everyday life. 🙂

An Energy Company for the Next Generation

“We are the last generation that can stop the climate crisis.”

This is the belief that unites the 60Hertz team.

With global temperatures rising every year, energy transition is one of the most critical keys to solving the crisis. Through IT innovation, we strive to build a more efficient and sustainable energy ecosystem and accelerate the adoption of renewable energy.

We believe that small technological changes can come together to create a big impact — for the next generation. 🙏

Join Us on the Journey

Be a part of 60Hertz's journey — a mission to protect lives and tackle the climate crisis. 🚀

We are committed to lifelong learning and growing together for a sustainable future.

We embrace change, eagerly acquire new skills and knowledge, share ideas openly, and support one another as the best teammates.

If you resonate with our vision, don’t hesitate to reach out.

We’re looking for people to run with us toward a better tomorrow. 🏃‍➡️

Hello!
We’re 60Hertz, a social venture specializing in energy IT solutions. 🚀

Today, we’re excited to share that the official 60Hz website has been completely redesigned to offer a faster, simpler, and more intuitive way to explore the technologies and services driving the energy transition.

✨ What’s New?

1. Faster, More Intuitive User Experience

Our new layout features a clean, responsive design optimized for both desktop and mobile—making it easier than ever to access key information.

2. Service-Centered Structure

We’ve restructured our content to highlight the full lifecycle of our renewable energy solutions—from production to management and distribution—all in one place.

3. Expanded Multilingual Support for Global Growth

To better connect with our international partners, we’ve expanded our English pages and are preparing additional language support as we scale globally.

🌍 Why Now?

As 60Hz expands into Vietnam, the U.S., Germany, and beyond, we want to better communicate our mission and innovations in the rapidly evolving fields of energy transition, carbon neutrality, and climate tech.

This new platform allows us to more clearly share our vision with the world.

👀 Visit Us Today

See how 60Hz is using technology to address the climate crisis—right from our newly refreshed homepage.

👉 https://60hz.io

We warmly welcome your visit, and we look forward to continuing our mission with greater transparency, innovation, and social impact.

Thank you.
—The 60Hz Team