1. Introduction

SNAP is the largest food assistance program in the United States. The US Department of Agriculture (USDA) funds the benefits and sets the rules. States determine eligibility, issue benefits, and run their own integrity units. USDA's Food and Nutrition Service (FNS) authorizes and polices the retailers that accept benefits. In 2026 USDA renamed FNS the Food and Nutrition Administration (FNA). This report keeps the name FNS because the studies and regulations it cites use that name.

Households receive benefits on an Electronic Benefit Transfer (EBT) card. The card works like a debit card restricted to a closed network of authorized retailers. A state loads the monthly benefit onto the household's account. The household buys eligible food at an authorized store, and the store's EBT processor debits the account. Within a few banking days the store receives the same amount in its bank account. Most EBT cards issued until recently used a magnetic stripe and a PIN. They carried no chip.

The scale is large on both sides of the transaction. USDA's Economic Research Service reports that SNAP served a monthly average of 41.7 million people in fiscal year 2024, about 12 percent of the US population, at a federal cost of $99.8 billion. Federal spending rose to about $102 billion in fiscal year 2025. Retailers number roughly 260,000. Superstores and supermarkets make up a small share of those stores but redeem most of the benefits. Convenience stores, small groceries, and specialty shops make up most of the authorized locations but redeem a small share of the dollars.

Fraud matters for two reasons. The first is budgetary. A benefit dollar that becomes 50 cents of cash for a recipient and 50 cents of profit for a store buys no food. The second is legitimacy. SNAP depends on public support, and that support erodes when voters believe the program leaks. Inflated claims about fraud do their own damage. They lead to controls that cost more than they save and that push eligible families out of the program. A sound design starts from accurate numbers (Figure 1).

2. A taxonomy of SNAP fraud

The Congressional Research Service groups SNAP integrity problems into trafficking, retailer application fraud, household errors and fraud, state agency errors and fraud, and external scams that steal benefits. This report uses a slightly finer grouping because each type calls for a different control (Figure 2).

Trafficking. Trafficking is the exchange of benefits for cash or anything other than eligible food. The typical case involves a recipient who lets a store clerk swipe the card for an amount, say $100, and receives a smaller amount of cash. Prosecutors in federal cases have described rates around 50 cents on the dollar, and some cases report higher or lower rates. Trafficking requires a retailer in almost every case, because only an authorized retailer can turn an EBT debit into a deposit. A recipient can also traffic by selling the card and PIN to a third party, who then shops with it.

Recipient eligibility fraud. An applicant may underreport earnings, omit a working household member, add a person who does not live in the home, or enroll in a second state. Honest mistakes produce the same outcomes, so eligibility problems show up in the error rate and only some of them are fraud.

Retailer ineligible sales and overcharging. A store may let EBT pay for items the law excludes, such as alcohol, tobacco, or paper goods. A store may also charge EBT shoppers more than cash shoppers, or inflate the price of real food items. The second practice can be collusive (the shopper accepts inflated prices in exchange for credit or cash) or predatory (the shopper does not notice).

Card skimming and cloning. Skimming is theft from recipients. A criminal attaches a device to a store's card reader or PIN pad. The device records the magnetic stripe data and the PIN. The criminal writes the data onto a blank card and drains the account, often within hours of the monthly benefit load. The recipient arrives at the store to find a zero balance. Magnetic stripe cards are easy to clone because the stripe carries static data that works on every swipe. A chip card generates a one-time code for each purchase, so copied data does not work for a second purchase.

Insider fraud. State employees with system access can create fictitious cases or issue benefits to accomplices. Cases are rare, and each can be large because the insider controls the record.

Organized rings. Rings combine the other types, for example by running several trafficking stores under nominee owners or skimming crews across states. They leave patterns across many cards and stores that no single transaction shows.

2.1 Fraud versus improper payments

The claim that "11 percent of SNAP is fraud" comes from the national payment error rate. USDA computes that rate each year from a quality control sample of cases. Reviewers check whether each sampled household received the correct benefit. Any difference above a small tolerance counts as an error, in either direction.

Four facts separate this rate from fraud. First, it includes underpayments, which are money the program failed to pay to eligible families. Second, it counts errors regardless of cause, and the largest causes are mistakes in income and household data made by households or caseworkers. USDA's own release for fiscal year 2024 stated that the rate is not a measure of fraud. Third, it measures eligibility and benefit amounts only. It does not measure trafficking at all, because a trafficked benefit was correctly issued to an eligible household before it was sold. Fourth, error rates move with administrative load. They fell to about 3 percent around 2013, then rose after the pandemic disrupted state operations and staffing (Figure 3).

The error rate is still a serious problem. Improper payments of about $10 billion a year are real money, and Congress has tied state cost sharing to error rates starting with fiscal year 2028. The point is narrower: the error rate and the fraud rate measure different things, and controls aimed at one do little for the other. The best available national fraud measure is the trafficking estimate. FNS's eighth study in that series, covering 2015 to 2017 and published in 2021, estimated that 1.6 percent of benefits were trafficked under its updated definition (about $1.0 billion a year) and 2.0 percent under the older definition (about $1.3 billion a year). The earlier 2012 to 2014 study put the rate near 1.5 percent. GAO has warned that the true figure is uncertain and could range from about $960 million to $4.7 billion a year, because the estimate rests on untested assumptions about how much of a trafficking store's volume is trafficked.

3. Anatomy of trafficking

The money flow of a single trafficking transaction is simple (Figure 4).

The core weakness. The EBT authorization message carries the store, the card, the amount, the date, and the time. It carries no list of items. FNS's 2016 feasibility study on capturing purchases at the point of sale confirmed that only total transaction amounts reach FNS. A trafficking store therefore never has to invent products. It keys in an amount, the network approves it, and the deposit follows. Every downstream check has to infer the fraud from the shape of the amounts and timings, because the record contains nothing else (Figure 5).

Both parties lie together. In most fraud, a victim has an incentive to report. In trafficking, the shopper and the cashier both gain. The recipient converts restricted benefits into cash, which can pay rent or utilities, or in worse cases buy drugs. The store keeps the spread. Neither party will complain, and any data either party enters can be shaped to look normal. This collusion property drives most of the design choices later in this report.

Why small stores dominate. The 2015 to 2017 study found that small stores (small and medium groceries and convenience stores) handled about 15 percent of redemptions but accounted for over 95 percent of trafficked dollars, and 99 percent under the updated definition. Several factors explain the concentration. A small store is often owner-operated, so one person controls the register, the cash drawer, and the books. Large chains run centralized point-of-sale systems with item scanning, cashier logins, and loss-prevention audits, and a cashier who trafficked would be stealing from the employer. Small stores also have few transactions per day, so a trafficking swipe does not need to hide in a long queue of scanned baskets. FNS itself excludes large stores from its watch list on the ground that their own controls deter trafficking.

The overcharging variant. A store can also traffic partially. The shopper buys real groceries worth $40, the register charges $70, and the shopper receives $15 in cash or store credit. The store earns $15 above its margin. This version leaves a basket that looks normal in size and timing, so it is harder for amount-based analytics to catch. It also has a predatory form, where the store inflates prices for EBT shoppers who do not check their receipts.

The economics. Any restricted currency trades at a discount to cash. A dollar of benefits that can only buy groceries is worth less than a dollar to a household that needs to pay rent. A household that already spends more than its benefit on food gains little from trafficking, because benefits replace cash food spending dollar for dollar. A household with an urgent cash need, or one whose benefit exceeds its food budget, may value a benefit dollar at well under a dollar. Trafficking monetizes that gap. A store that can offer cash at 50 to 70 cents per dollar captures the remainder. Enforcement leaves the gap in place and raises the price of crossing it, by adding the risk of disqualification and prosecution to the store's side of the trade.

4. Current detection and enforcement

4.1 Transaction analytics: ALERT

FNS's main detection tool for retailer trafficking is the Anti-Fraud Locator using EBT Retailer Transactions (ALERT). State EBT processors send FNS daily records of every SNAP transaction. GAO reported in 2018 that ALERT scanned about 250 million transactions per month. The system assigns each store a numeric score for the likelihood of trafficking. Stores above a threshold join a watch list, and analysts prioritize them using factors such as average transaction size relative to store type. Analysts also compare a suspect store with similar stores in the same ZIP code. CRS reported that over 80 percent of the retailer trafficking FNS detects is found mainly through EBT transaction analysis (Figure 6).

FNS charge letters and agency decisions describe the patterns that drive these cases:

• A large number of transactions in repeated or round dollar values, such as many sales ending in .00.
• Multiple transactions from one household account within a short window, a pattern unusual for a small store with limited stock.
• Transactions that are excessively large for the store's size and type.
• Multiple households making similar transactions within a short period.
• Accounts drained in one or two swipes, sometimes by out-of-state cards.

Each pattern is a proxy for "no real basket behind this amount." Round totals are rare when real prices are summed. Repeat swipes from one card suggest the store is splitting a large trafficking amount to avoid a size flag. Large totals at a store with a few shelves of stock suggest the store sells more food than it holds.

4.2 Undercover investigations and penalties

FNS investigators and USDA's Office of Inspector General conduct undercover buys, in which an investigator with a test card offers to sell benefits or to buy ineligible items. Under state law enforcement bureau agreements, which GAO counted in 28 states in 2018, state and local police also run their own undercover cases with SNAP cards.

Penalties are set by regulation. For retailers, 7 CFR 278.6 provides:

The regulation lets FNS rely on "evidence obtained through a transaction report under an electronic benefit transfer system." That clause is what lets ALERT data alone support a permanent disqualification.

For recipients, 7 CFR 273.16 sets disqualification periods for an intentional program violation: 12 months for a first violation, 24 months for a second, and permanent for a third. A court conviction for trafficking $500 or more brings permanent disqualification on the first occasion. A fraudulent statement about identity or residence to receive benefits in more than one place brings a 10-year bar. Transactions involving firearms, ammunition, or explosives bring permanent disqualification. Transactions involving controlled substances bring 24 months, then permanent.

4.3 Eligibility and retailer standards

On the eligibility side, states verify income and identity using federal and state data sources. The 2018 Farm Bill required a National Accuracy Clearinghouse (NAC) to stop the same person from receiving benefits in two states at once. FNS issued an interim final rule in October 2022 requiring all state agencies to join the NAC and to act on its match results, with full compliance due by 2027. Before the NAC, states relied on the slower Public Assistance Reporting Information System (PARIS) for interstate matching.

On the retailer side, FNS published a final rule in December 2016 to raise stocking standards. It required stores qualifying on inventory to carry at least seven varieties in each of four staple food categories, with perishable items in at least three categories and at least three units of each variety. The aim was partly integrity: a "store" with a few cans on a shelf and a busy EBT terminal is a classic trafficking front. Appropriations riders blocked enforcement of the variety and breadth provisions for years. USDA proposed updated standards in 2025, and its current guidance says retailers must comply starting in 2026.

4.4 Skimming response

The Consolidated Appropriations Act, 2023 (P.L. 117-328, Division HH, section 501) gave states temporary authority to replace stolen benefits with federal funds, limited to the lesser of the amount stolen or two months of benefits, and to two replacements per household per fiscal year. A later continuing resolution extended the window to cover thefts through December 20, 2024. Congress did not extend it further. According to USDA figures cited by the Center on Budget and Policy Priorities, states replaced more than $150 million in stolen benefits for over 315,000 households between January 2023 and September 2024. The underlying fix is the card itself. California became the first state to issue chip-and-tap EBT cards in 2025, and state officials told legislators that all clients had received new cards by spring 2025. Other states have started similar migrations (Figure 7).

4.5 Limits of the current approach

The current model has five structural limits.

First, it detects after the fact. ALERT reads completed transactions, and the store has already been paid. By the time a store is disqualified, it may have trafficked for months, and the owners can reopen under a new name.

Second, it sees only amounts. Without items, ALERT cannot tell a real $87.43 basket from a trafficked $87.43 swipe. Smart traffickers learn the flags and stop using round amounts.

Third, it targets stores and largely misses recipients. EBT data alone is generally not enough to disqualify a recipient, so states struggle to act on the cardholder side of ALERT cases.

Fourth, it does not scale with investigator capacity. GAO found that FNS reauthorized all stores on a five-year cycle regardless of risk, and that its trafficking estimate rested on assumptions it had not tested.

Fifth, the card was weak. Magnetic stripe cards made skimming cheap. The program bore part of the loss through replacement, and recipients bore the rest after the replacement authority ended. Figures A1 to A4 in Appendix A model this response as UML operations diagrams.

5. Design principles

Four principles shape the architecture in the next section.

6. A layered program and software architecture

The architecture has four transaction-path layers and one analytics layer that reads from all of them. Confirmed cases flow back into the analytics layer as labels (Figure 9).

The transaction-path layers act on each enrollment or sale. The analytics layer acts on aggregates over time, because most fraud signals are weak in a single event and strong in a pattern. Figures A5 to A7 in Appendix A model this architecture as UML software diagrams.

6.1 Eligibility layer

The eligibility layer decides who receives benefits and how much. Its job is to stop overpayments before the first payment, which is cheaper than recovering them later.

Automated income matching. At application and at recertification, the system should query payroll data (such as commercial employment verification services and state new-hire registries), state wage records, federal tax data where the law allows, and bank account verification. A discrepancy above a tolerance triggers a request for documents instead of a denial. The goal is to replace self-reported income with verified income where a source exists, and to save caseworker time for cases where no source exists, such as informal or gig work.

National duplicate-enrollment check. Every new application should check the NAC before the first issuance, and every active case should be rechecked on a schedule, such as monthly. A match pauses the second state's issuance and opens a resolution task with notice to the household. Many matches are benign, such as a family that moved and has not closed the old case. The software should treat a match as a question to resolve quickly, and it should close the old case when the household confirms the move.

The eligibility check runs at signup, at recertification, and on a schedule, and it settles every question before the first payment.

def check_eligibility(application):
    # Verified income replaces self-reported income where a source exists.
    sources = [payroll_data, new_hire_registry, state_wage_records,
               federal_tax_data,  # only where the law allows
               bank_account_verification]
    verified = [s.income_for(application.household) for s in sources if s.covers(application)]
    if not verified:
        assign_caseworker(application)  # informal or gig work has no source
    for income in verified:
        if abs(income - application.reported_income) > INCOME_TOLERANCE:
            return request_documents(application)  # a mismatch asks, never denies
    match = NAC.find_active_case(application.household)
    if match:
        pause_issuance(application)
        open_resolution_task(application, match, notify_household=True)
        # Most matches are moves; close the old case on confirmation.
        return "pending_resolution"
    return approve_first_payment(application)

def recheck_active_cases(active_cases):  # on a schedule, such as monthly
    for case in active_cases:
        if NAC.find_active_case(case.household, excluding=case):
            pause_issuance(case)
            open_resolution_task(case, notify_household=True)

Household composition checks. Cross-checks against other benefit programs and state records can flag a member listed in two households. These checks catch fraud and honest error alike, so the response should be a request for clarification.

6.2 Credential layer

The credential layer controls who can spend a benefit. Its main target is theft from recipients.

Chip and contactless cards. EMV chip cards defeat magnetic stripe skimming, because a cloned stripe or a captured one-time code cannot authorize a second purchase. Tap-to-pay reduces exposure to tampered card slots. California's rollout shows the main obstacle: retailers must upgrade terminals, and for a time most transactions still fell back to the stripe. The program should set a date after which stripe fallback is declined except at stores with an approved exception.

Phone wallets. Mobile wallet credentials add device binding and biometric unlock. The 2018 Farm Bill authorized mobile payment pilots for SNAP. A wallet also gives the program a direct channel to the recipient.

Recipient app controls. A recipient app should let the household lock the card between uses, block out-of-state and online transactions by default, and receive an alert for every swipe. Locks and geography blocks stop most cloned-card drains. Per-swipe alerts let a household report theft within minutes.

Countering load-day drains. Skimming crews strike when the monthly benefit lands, because that is when the balance is highest. Two controls help. The first is to vary the load time within the day or to spread loads across days by case number, so a crew cannot predict the exact moment. The second is a step-up check for large spending soon after a load: if more than a set share of the balance is spent within a short window, at a store far from the recipient's usual stores, the system asks for confirmation in the app before approving. The check must fail open for recipients without phones, or it will cut off the households least able to absorb a delay (Figure 10).

The credential check runs on every swipe and asks the household to confirm only a large spend soon after benefits load.

def authorize_swipe(card, txn, settings, now):
    send_swipe_alert(card.household, txn)  # households report theft within minutes
    if txn.entry_mode == "stripe" and now >= STRIPE_FALLBACK_DEADLINE:
        if not txn.store.has_approved_exception:
            return decline("STRIPE_FALLBACK_ENDED")
    if settings.card_locked:
        return decline("CARD_LOCKED")
    if txn.is_out_of_state and settings.block_out_of_state:  # on by default
        return decline("OUT_OF_STATE_BLOCKED")
    if txn.is_online and settings.block_online:  # on by default
        return decline("ONLINE_BLOCKED")
    if needs_step_up(card, txn, now):
        if card.household.has_app:
            if not confirm_in_app(card.household, txn):
                return decline("NOT_CONFIRMED")
        # No phone means fail open, never a cutoff.
    return approve(txn)

def needs_step_up(card, txn, now):
    soon_after_load = now - card.last_load_time <= STEP_UP_WINDOW
    spent = card.spent_since_last_load + txn.amount
    large_share = spent > STEP_UP_SHARE * card.balance_at_last_load
    far_away = distance(txn.store, card.usual_stores) > STEP_UP_DISTANCE
    return soon_after_load and large_share and far_away

6.3 Transaction layer

The transaction layer is where the program can close the core weakness: the payment record with no item list.

Mandatory item-level basket data. Each EBT sale should carry a line for each item: the barcode (UPC or PLU), quantity, unit price, and SNAP-eligible flag. FNS's 2016 feasibility study showed that item-level data can be captured from integrated electronic cash registers and matched to EBT transaction records at above 99 percent accuracy using card number, date, store, and amount. The new standard would carry the basket in the authorization message itself or in a linked message sent within seconds.

Real-time rules. With item data in the message, the processor can reject a sale that includes ineligible items before it completes. It can also reject or flag lines for products the store is not known to stock. The program would maintain a per-store product catalog, seeded from the store's own price list at authorization and from wholesale records over time. A convenience store that suddenly sells 30 pounds of beef in one basket, a product it has never bought from a supplier, would see the line flagged.

The processor validates the itemized basket inside the authorization and declines a bad one at the register with a reason code.

def validate_basket(txn, products, store_catalog):
    total = 0
    for line in txn.basket_lines:
        product = products.get(line.upc)  # UPC or PLU
        if product is None:
            return reject(txn, "UNKNOWN_BARCODE", line)
        if not product.snap_eligible:
            return reject(txn, "INELIGIBLE_ITEM", line)
        # Catalog seeded from price list, then supplier records.
        if line.upc not in store_catalog[txn.store]:
            return reject(txn, "NOT_STOCKED", line)
        total += line.quantity * line.unit_price
    if total != txn.amount:
        return reject(txn, "TOTAL_MISMATCH")
    return accept(txn)

def reject(txn, reason_code, line=None):
    # Repeated unstocked lines are a signal for the monthly score.
    report_to_analytics(txn.store, reason_code, line)
    return Decline(txn, reason_code)

Small-store capacity. Many small stores do not run integrated scanning registers. The standard needs a low-cost path, such as a subsidized, certified tablet point-of-sale app, or the rollout will drive stores out of the program.

6.4 Merchant payout layer

Card networks and payment processors face the same problem SNAP faces: some merchants are fronts for fraud. Processors such as Stripe and PayPal manage that risk at payout time. The SNAP payout layer should adopt the same tools.

Probation for new stores. A newly authorized store, or a store under new ownership, starts in a probation tier. It receives payouts on a longer delay, faces a monthly volume cap set from its stated size and stock, and gets an early field visit. Trafficking stores often show high volume soon after authorization, so probation targets the riskiest period.

Risk-tiered delays and caps. Every store sits in a tier set by its analytics score. Low-risk stores get the standard settlement time. Higher tiers get longer settlement delays and volume caps. A delay of a week or two does not stop an honest store from operating. It does let the program withhold funds when a case opens, which makes recovery possible (Figure 11).

Holds pending review. When a store's score crosses a high threshold, the program can hold part of its payouts until review. A hold of this kind must have a time limit and a clear path to release, or it becomes a penalty without process.

Recovery reserve. For high-tier stores, a rolling reserve (a share of payouts held for a period) gives the program a fund to recover from after a disqualification.

The payout layer pays clean stores on the standard schedule and slows, caps, or holds money as a store's tier climbs.

def payout_treatment(store):
    if store.tier == "disqualified":
        return Action(pay=False, recover_from=store.reserve)
    if store.tier == "probation":
        return Action(delay=PROBATION_DELAY, field_visit="early",
                      monthly_cap=cap_from(store.stated_size, store.stated_stock))
    if store.tier == "normal":
        return Action(delay=STANDARD_SETTLEMENT)
    if store.tier == "elevated":  # a delay of a week or two
        return Action(delay=ELEVATED_DELAY, monthly_cap=ELEVATED_CAP)
    if store.tier == "high_risk":
        return Action(delay=HIGH_RISK_DELAY, monthly_cap=HIGH_RISK_CAP,
                      hold_share=HOLD_SHARE,  # hold until review
                      hold_expires=HOLD_TIME_LIMIT,  # needs a release path
                      reserve_share=RESERVE_SHARE)

def next_tier(store, score, today):
    if store.case and store.case.decision == "disqualify":  # a person decides
        return "disqualified"
    if today - store.authorized_or_new_owner_on < PROBATION_PERIOD:
        return "probation"  # trafficking stores spike soon after authorization
    if score >= HIGH_RISK_THRESHOLD:
        return "high_risk"
    return "elevated" if score >= ELEVATED_THRESHOLD else "normal"

6.5 Analytics layer

The analytics layer reads from all four transaction-path layers and from third-party sources. It produces store, card, and case scores, and it feeds the investigation queue. Two methods matter most beyond price anomaly detection, which Section 7 covers.

Inventory reconciliation. Compare EBT sales per product category against the store's wholesale purchases of that category. A store cannot sell 400 cartons of eggs in a month if its suppliers delivered 50. Purchase data can come from supplier invoices that the store submits and from data feeds provided by large distributors under agreement. Without item data, reconciliation works at the level of total food purchases against total EBT redemptions. With item data, it works per product. The limit is that a store can buy stock for cash at a wholesale club, which leaves no supplier record in a distributor feed. The program should make purchase records a condition of authorization: a store must keep invoices or receipts for food it sells and submit them on request. Random audits of a sample of stores each year, plus targeted audits of high scorers, keep the requirement credible. A store that cannot show purchases to support its sales has a problem regardless of what its baskets say (Figure 12).

Reconciliation compares what a store sold through EBT with what its suppliers delivered, evidence the store does not write.

def reconcile_inventory(store, month):
    # Wholesale-club cash buys leave no distributor feed record.
    if not store.purchase_records_submitted(month):
        request_purchase_records(store, month)  # a condition of authorization
    invoices = distributor_feeds.invoices(store, month) + store.submitted_invoices(month)
    if not store.has_item_data(month):
        sold = sum(t.amount for t in store.ebt_transactions(month))
        bought = sum(i.food_total for i in invoices)
        return [Flag(store, month, "ALL_FOOD")] if sold - bought > TOTAL_TOLERANCE else []
    delivered = units_by_upc(line for i in invoices for line in i.invoice_lines)
    sold = units_by_upc(line for t in store.ebt_transactions(month) for line in t.basket_lines)
    flags = []
    for upc, units_sold in sold.items():
        gap = units_sold - delivered.get(upc, 0)
        if gap > UNIT_TOLERANCE:
            flags.append(Flag(store, month, upc, gap))
    return flags

# Report example: 400 cartons of eggs sold, 50 delivered.

Network and graph analysis. Build a graph with cards and stores as nodes and transactions as edges. Trafficking rings leave clusters: groups of cards that all visit the same few suspicious stores, often traveling past closer and larger stores to do so. A single-transaction rule sees a normal-looking $60 sale. The graph sees 200 cards that spend nearly all their benefits at three small stores owned by related parties. Community detection, shared-owner links from authorization records, and shared bank accounts on payout records together reveal rings that no store-level score would. The same graph helps on the recipient side: a card that appears in many confirmed trafficking cases is a candidate for a state investigation with evidence beyond a single transaction pattern (Figure 13).

The ring finder builds a card to store graph and flags groups of cards whose spending piles into the same few stores.

def find_rings(transactions):
    graph = Graph()
    for txn in transactions:
        graph.add_edge(txn.card, txn.store, weight=txn.amount)
    rings = []
    for cluster in community_detection(graph):
        stores = cluster.stores_by_spend()[:FEW_STORES]
        cards = [c for c in cluster.cards
                 if graph.spend_share(c, stores) >= CONCENTRATION_SHARE]
        if len(cards) < MIN_RING_CARDS:
            continue
        # Rings travel past closer and larger stores.
        skipped = count_cards_passing_closer_larger_stores(cards, stores)
        linked = shared_owners(stores) or shared_payout_accounts(stores)
        rings.append(Ring(stores, cards, skipped, linked))
    return rings

def recipient_leads(graph, confirmed_cases):
    # Evidence beyond one transaction pattern, for state investigators.
    return [c for c in graph.cards
            if confirmed_cases.count_with(c) >= RECIPIENT_CASE_COUNT]

# Report example: 200 cards, nearly all benefits at three stores.

Feedback. Every closed case, whether confirmed or cleared, becomes a labeled example. The scoring models retrain on these labels. Cleared cases matter as much as confirmed ones, because they teach the models which patterns are benign, such as round prices at a store that prices in whole dollars.

7. Price anomaly detection without human basket review

Item-level data creates a new problem: volume. Retailers process millions of SNAP transactions per day. No program can afford a person to look at baskets. The design question is how to turn that volume into a short list of stores worth a human's time, so that operating cost grows with investigator headcount while transaction volume affects only computing cost. Figure A8 in Appendix A shows the monthly scoring run as a sequence.

7.1 Reference prices

The system builds a reference price for each barcode in each region from all stores' basket data. For a given barcode and region in a given month, the reference is a robust central value of observed prices, such as the median, with a spread measure such as the interquartile range. Separate references for store classes (supermarket, convenience store, small grocery) reflect the fact that convenience stores charge more for the same item. Products with few observations borrow strength from related products in the same category and from neighboring regions (Figure 14).

7.2 Score stores, not baskets

One odd price means little. A store may run a promotion, price a slow item high, or key a price wrong. Independent stores set their own prices, and small stores pay more at wholesale than chains. Scoring each basket would flood the system with noise.

The unit of scoring is the store-month. For each store and month, the system computes:

• The excess price share: the sum over lines of (price paid minus the upper bound of the reference range, when positive), divided by total EBT sales.
• The share of lines priced above the reference range.
• Basket plausibility: how far the mix of items departs from what EBT shoppers buy at similar stores (for example, baskets made of a few high-priced items that recur in round-total combinations).
• Supply consistency: EBT sales per category divided by known purchases per category, from the inventory reconciliation.

These features feed a model trained on labels from past cases. Before scoring, the system applies statistical shrinkage so that a store with few transactions does not get an extreme score from a handful of odd lines.

The monthly run builds a reference price per barcode and region, then scores each store-month from all of its lines together.

def reference_prices(lines, month):
    refs = {}
    for (upc, region, store_class), prices in group(lines, by=(upc, region, store_class)):
        if len(prices) < MIN_OBSERVATIONS:  # borrow from category and neighbors
            prices += related_prices(category_of(upc), neighboring_regions(region))
        mid, spread = median(prices), interquartile_range(prices)
        refs[(upc, region, store_class)] = Reference(mid, upper=mid + REF_RANGE_WIDTH * spread)
    return refs

def score_store_month(store, month, refs, reconciliation, model):
    lines = store.ebt_basket_lines(month)
    upper = {l: refs[(l.upc, store.region, store.store_class)].upper for l in lines}
    sales = sum(l.quantity * l.unit_price for l in lines)
    excess = sum(max(0, l.unit_price - upper[l]) * l.quantity for l in lines)
    features = {
        "excess_price_share": excess / sales,
        "share_lines_above": count(l for l in lines if l.unit_price > upper[l]) / len(lines),
        "basket_plausibility": mix_distance(store.baskets(month), peers(store.store_class)),
        "supply_consistency": reconciliation.sales_vs_purchases_by_category(store, month),
    }
    raw = model.predict(features)  # trained on labels from past cases
    # Shrinkage: one odd basket cannot swing a small store.
    score = shrink(raw, toward=peer_average, n=len(lines), strength=SHRINKAGE_STRENGTH)
    return StoreMonthScore(store, month, score, features)

7.3 Rank by expected loss

The output of scoring is a ranked list of stores by expected loss:

expected loss = probability of fraud x estimated excess dollars per year

The probability comes from the model. The excess dollars come from the excess price share and the supply gap, multiplied by the store's EBT volume. The program then acts on the list through a funnel (Figure 15).

The automated tier handles most stores that score above normal. A warning letter tells a store its prices sit well above its peers and invites an explanation. A payout delay or volume cap limits exposure without accusing anyone. These actions are reversible and need no investigator time. They also deter: a store that knows the system watches its prices has less reason to inflate them.

7.4 Cost model

Human cost in this design scales with the number of investigators. Transaction volume drives only computing cost, which is small. That property follows from three rules.

First, set the investigator budget first. The program decides how many investigator hours it can fund in a period. That number fixes N, the count of cases the queue can absorb.

Second, review only what the budget covers. The queue takes the top N stores by expected loss. Stores below the cutoff stay in the automated tier, where their scores keep updating. A store that keeps rising will eventually enter the queue.

Third, review a case only when the expected benefit exceeds the review cost. Even within budget, a case with low expected loss should not consume a review. The test is:

expected loss x share prevented or recovered by action > cost of one review

The share prevented or recovered reflects that a review does not recover every dollar. It may end future losses through disqualification, recover part of past losses, and deter others.

Excess dollars per year equal monthly sales times excess share times 12. For Store A: $60,000 x 0.30 x 12 = $216,000, and $216,000 x 0.8 = $172,800.

Store E fails the threshold: a $6,000 review to protect $960 is a loss. It receives a warning letter and stays under watch. Stores A through D all pass. If the budget covers two reviews this cycle, A and B go to investigators. C and D receive payout delays and volume caps, and they remain at the top of next month's list. Note that Store C has the largest sales but a low excess share and a low probability. Ranking by sales volume alone, a common heuristic, would have sent the wrong store first (Figure 16).

The planner ranks stores by expected loss, sends the budget's top N to people, and puts the rest on automatic actions.

def plan_reviews(scores, investigator_hours):
    n = investigator_hours // HOURS_PER_REVIEW  # budget fixes N before the run
    for s in scores:
        # Excess share comes from excess prices and supply gap.
        s.expected_loss = s.probability_of_fraud * s.monthly_ebt_sales * s.excess_share * 12
    ranked = sorted(scores, key=expected_loss, descending=True)
    worth = [s for s in ranked if s.expected_loss * SHARE_PREVENTED > REVIEW_COST]
    for s in worth[n:]:
        apply(s.store, [Action("payout_delay"), Action("volume_cap")])  # back on next list
    for s in ranked:
        if s not in worth and s.score > NORMAL_SCORE:
            apply(s.store, [Action("warning_letter")])
    return [Case(s.store, s.expected_loss) for s in worth[:n]]

def close_case(case):
    # Cleared cases teach the model which patterns are benign.
    training_labels.add(case.store_month_score, label=case.outcome)

# Worked example: REVIEW_COST 6,000, SHARE_PREVENTED 0.5, N = 2
# store: expected_loss = p x sales x share x 12; x 0.5 vs 6,000; action
# A: 0.8 x 60,000 x 0.30 x 12 = 172,800; 86,400 > 6,000; review, rank 1
# B: 0.6 x 25,000 x 0.40 x 12 = 72,000; 36,000 > 6,000; review, rank 2
# C: 0.3 x 120,000 x 0.05 x 12 = 21,600; 10,800 > 6,000; delay and cap, past N
# D: 0.4 x 15,000 x 0.20 x 12 = 14,400; 7,200 > 6,000; delay and cap, past N
# E: 0.2 x 8,000 x 0.10 x 12 = 1,920; 960 < 6,000; warning letter

7.5 Recipient-side reporting

Recipients can supply a free signal against overcharging. The recipient app should show an itemized receipt for each EBT purchase, with a "price looks wrong" button on each line. Reports feed the store's score as one more feature, weighted by the reporter's history so that one angry customer cannot sink a store. Reports also help the household directly, by showing what each item cost.

This channel does nothing against trafficking. The trafficking shopper colludes with the store and will never press the button. Recipient reporting is a tool for the predatory form of overcharging, where the store cheats its customer. That distinction should shape how the program weights these reports: they are strong evidence of predatory pricing and no evidence about trafficking.

8. Trade-offs and harms

Every control in this report imposes costs on honest participants. The table lists the main ones (Figure 17).

Privacy. Item-level data is the most sensitive control. Once the state holds a record of every item every SNAP household buys, pressure will follow to use it for diet policing, immigration enforcement, or commercial sale. The data design should limit use by statute to program integrity and approved research. It should keep raw baskets for a short period, such as 13 months, then retain only store-level aggregates. It should separate identity from basket data so that analysts work with tokenized card numbers, and only a case opened by an investigator can resolve a token to a household.

Access. Small stores are often the only food retailers in poor urban and rural areas. They also carry most trafficking. A rule that removes trafficking stores also removes some honest ones, and each loss can strand households far from a supermarket. Mitigation requires subsidy for equipment and an explicit access test before disqualifying the last authorized store in an area, with a path to a civil money penalty instead.

Due process. ALERT cases already rest mostly on transaction data, and stores have ten days to respond to a charge letter. Adding automated holds and caps raises the stakes of a wrong score. The program should publish appeal timelines, track how often automated actions reverse on appeal, and pay interest on wrongful holds.

Human review before cutoff. No household should lose benefits because of an automated score. Scores can open a case. A person decides it, with notice and a hearing, as 7 CFR 273.16 already requires for intentional program violations.

9. The policy alternative

Trafficking exists because SNAP benefits are restricted to food at authorized stores while cash is unrestricted. If the program paid benefits as unrestricted cash, trafficking would end by definition, because there would be no discount between a benefit dollar and a cash dollar for anyone to capture. The retailer authorization system, ALERT, undercover buys, and most of the merchant-side architecture in this report would become unnecessary.

That is a policy choice, and it carries its own debates. Supporters point to lower administrative cost, more dignity and flexibility for households, and economic research finding that, for most households, SNAP affects food spending much as an equal amount of cash would. Opponents argue that restricting benefits to food is the program's purpose and the basis of its political support, that cash could shift spending away from food for some households, and that the change would remove an effect that supports grocery retailers. A middle path, such as a partial cash-out, would shrink the trafficking discount without ending it.

This report takes no position on that question. The point for designers is that the software architecture addresses a problem the policy creates. If policy changes, the integrity problem changes with it: eligibility fraud and payment theft remain, and trafficking disappears.

10. Implementation roadmap

The architecture is too large to deploy at once, and some parts depend on others. A three-phase rollout orders the work by cost, dependency, and the size of the loss each step addresses (Figure 18).

Phase 1: credentials and payout risk. Complete the national move to chip and contactless EBT cards. Launch a recipient app with card lock, geography and online blocks, and per-swipe alerts. Introduce merchant risk tiers using the existing ALERT score: probation for new stores, settlement delays and caps for high tiers. These steps need no new data standard and attack skimming and hit-and-run trafficking directly.

Phase 2: item-level data standard. Define and publish an item-level basket standard for EBT messages. Certify point-of-sale vendors against it. Fund a low-cost certified option for small stores. Turn on real-time rejection of ineligible items. Begin building reference prices and per-store product catalogs. Set privacy rules in regulation before data collection starts.

Phase 3: analytics and the investigation queue. Add inventory reconciliation with distributor feeds and purchase-record requirements. Build the card-store graph. Deploy store-month price scoring and expected-loss ranking. Size the investigation queue to the budget and run the feedback loop from closed cases.

Each phase should ship with measurement. Phase 1 should report skimming claims per thousand cards before and after the switch. Phase 2 should report the share of EBT volume carrying item data and the count of small stores that left the program. Phase 3 should report the confirmation rate of reviewed cases, reversal rates on appeal, and estimated trafficking from the next FNS study. Without measurement, the program cannot tell whether controls pay for themselves.

11. Conclusion

SNAP fraud is smaller and more specific than public debate suggests. The headline error rate near 11 percent measures payment accuracy, and it counts mistakes in both directions. The best estimate of trafficking, the program's signature fraud, is about 1.6 to 2.0 percent of benefits, concentrated in small stores. Skimming is a separate problem whose victims are recipients.

Trafficking persists because the EBT record carries amounts without items and because both parties to the lie gain from it. Controls that rely on data the shopper or the store enters cannot fully solve it. The architecture in this report responds in layers: verify eligibility from outside sources before the first payment, harden the card, carry items in the transaction, manage payouts the way processors manage risky merchants, and reconcile what stores sell against what their suppliers delivered. Price anomaly detection runs at the store-month level, ranks stores by expected loss, and sends only what the budget covers to people, so that oversight cost tracks investigator headcount.

Each control harms some honest participants, through lost privacy, lost store access, delayed payouts, or wrongful flags. Those costs belong in the same calculation as the fraud the controls stop. A program that counts them, publishes its error and reversal rates, and keeps a person between any score and a family's food will protect both the budget and the trust that the program depends on.

Appendix A. UML models

These models turn the design into operations and software specifications. The operations models come first.

A.1 Operations

The figures so far follow the money and the fraud. The next four show the operations side in UML, the notation software teams use to specify systems. The first is a use case diagram. It names each party that touches the integrity program and what each one does there, from the household and the store to the federal retailer analyst at FNS (renamed FNA in 2026).

Two points stand out. Recipients and retailers run controls themselves: a household locks its own card, and a store submits its own purchase records. And every sanction rests with a person, as section 8 requires.

An activity diagram shows how one case moves between parties. It starts in software. The analytics system scores every store each month, and only stores in the top N reach a federal analyst; the rest get an automated warning letter, payout delay, or volume cap. Once a case opens, three lines of evidence run at the same time: supplier records, an undercover buy, and the store's own purchase records.

The case file joins them before anyone decides. A sanction can go to independent review, and every outcome, closed, upheld, or reversed, becomes a label for next month's scores.

The same process, seen from the case record, is a state machine. Each box is a status the case can hold, and each arrow names the event, guard, and action that move it. The design rules from sections 6 to 8 become guards here.

A case opens only when its expected loss beats the review cost within budget. A payout hold starts when the case enters the queue and lifts if the evidence shows no violation. Every sanction can go to appeal before the case becomes final.

The last diagram turns to the recipient side, where the loss is theft from families. Section 6.2 proposes a recipient app with per-swipe alerts and a card lock, and section 4.4 describes how benefit replacement worked. The activity diagram joins the two.

A family can stop a drain within minutes of the first unknown swipe. The response then splits: the state reissues the card and decides whether the stolen benefits come back. Under the facts in section 4.4, federal replacement covered thefts only through December 20, 2024.

A.2 Software

The component diagram recasts the layered design as software. Each box is a deployable component. A ball marks an interface the component offers, and a cup marks one it needs. The real-time path answers inside a sale: the gateway calls the eligibility, credential, and basket checks, then settles through the payout risk service.

Batch analytics reads the stream of sales once a month. Three evidence services feed one scoring engine. External sources sit outside the packages, because the program reads them and cannot change them.

The sequence diagram follows one EBT purchase once the basket travels with the authorization. The processor checks every line against SNAP eligibility and the store catalog before it touches the balance. A valid basket then passes a risk check. Only a large spend soon after the monthly load triggers a step-up confirmation in the recipient app, and a recipient without a phone fails open.

An invalid basket is declined at the register. The processor still reports the line, because a store that keeps keying items it never stocks is a signal for the monthly score.

The class diagram names the records the software keeps. Two structures mirror each other: a transaction owns its basket lines, and a supplier invoice owns its invoice lines. Both kinds of line point at the same product barcode. That shared key makes reconciliation possible, because the store writes one side and its suppliers write the other.

Scores attach to a retailer and a month, never to a single basket. A score can open a case or trigger an automatic action, and every action carries an expiry and an appeal.

The second sequence diagram shows the batch side. A scheduler starts the run once a month. For each store, the scoring engine gathers three kinds of evidence: excess prices against the regional reference, sales against supplier purchases, and the store's place in the card-store graph. It scores the store-month with shrinkage, so a small store with a few odd lines does not jump the queue.

The ranker sorts stores by expected loss. The investigator budget fixes N before the run starts, so transaction volume never changes how many cases people see.

References

1. Center on Budget and Policy Priorities. "Congress Must Extend Protections for SNAP Households Who Are Victims of Benefit Theft." Blog post, 2024. cbpp.org: SNAP benefit theft
2. Code of Federal Regulations. 7 CFR 273.16, Disqualification for intentional Program violation. Accessed via Legal Information Institute, Cornell Law School. law.cornell.edu: 7 CFR 273.16
3. Code of Federal Regulations. 7 CFR 278.6, Disqualification of retail food stores and wholesale food concerns and imposition of civil money penalties in lieu of disqualifications. Accessed via Legal Information Institute, Cornell Law School. law.cornell.edu: 7 CFR 278.6
4. Congressional Research Service. Supplemental Nutrition Assistance Program: Errors and Fraud (IF10860). Updated April 7, 2025. everycrsreport.com: IF10860
5. Congressional Research Service. Errors and Fraud in the Supplemental Nutrition Assistance Program (SNAP) (R45147). Updated September 28, 2018. everycrsreport.com: R45147
6. Congressional Research Service. Supplemental Nutrition Assistance Program (SNAP): Benefit Theft Through Electronic Benefit Card Skimming (IN12419). congress.gov: IN12419
7. Consolidated Appropriations Act, 2023. Public Law 117-328, Division HH, section 501.
8. Federal Register. "Enhancing Retailer Standards in the Supplemental Nutrition Assistance Program (SNAP)." Final rule, 81 FR 90675, December 15, 2016. federalregister.gov: 81 FR 90675
9. Federal Register. "Supplemental Nutrition Assistance Program: Requirement for Interstate Data Matching To Prevent Duplicate Issuances." Interim final rule, October 3, 2022. federalregister.gov: interstate data matching
10. US Department of Agriculture, Economic Research Service. "Supplemental Nutrition Assistance Program (SNAP) average monthly participation and inflation-adjusted annual program spending, fiscal years 2000-24." Chart. ers.usda.gov: participation and spending chart
11. US Department of Agriculture, Food and Nutrition Service. Feasibility Study of Capturing Supplemental Nutrition Assistance Program (SNAP) Purchases at the Point of Sale. Prepared by IMPAQ International. November 2016.
12. US Department of Agriculture, Food and Nutrition Service. Fiscal Year 2024 SNAP Quality Control Payment Error Rates. 2025. fns.usda.gov: FY 2024 QC report
13. US Department of Agriculture, Food and Nutrition Service. "USDA Releases Annual SNAP Payment Error Rates for FY 2024." Press release, June 27, 2025.
14. US Department of Agriculture. "USDA Announces FY 2025 State Payment Error Rates in SNAP." Press release, June 24, 2026. usda.gov: FY 2025 state error rates
15. US Department of Agriculture. "USDA Announces Actions to Better Serve States, Nutrition Program Recipients, and the American Taxpayer." Press release on the Food and Nutrition Administration, April 30, 2026. usda.gov: FNS restructuring
16. US Government Accountability Office. Supplemental Nutrition Assistance Program: Actions Needed to Better Measure and Address Retailer Trafficking (GAO-19-167). December 2018. gao.gov: GAO-19-167
17. Wilson, Hoke (Manhattan Strategy Group). The Extent of Trafficking in the Supplemental Nutrition Assistance Program: 2015-2017. USDA Food and Nutrition Service, Office of Policy Support, September 2021. fns.usda.gov: trafficking 2015-2017
18. Contra Costa County Employment and Human Services Department. "New EBT Card Security & Technology Upgrade." February 2025. ehsd.org: EBT card upgrade

I'm a software engineer, innovation advocates and technology investor. I created Golang Vietnam Community and helped run WeBuild Community. On those platforms, we connect with all the makers and software engineers from different background and support them on their side projects.

I'm the founder of Dwarves Foundation (@dwarvesf), a technology firm that focuses on tech know-how R&D and massive application/distribution via a wide range of activities and services, e.g. offshore centre, software consulting, open-source software development. At Dwarves Foundation, we choose innovation to be one of our core values that form ideas to affect the general society undoubtedly. Innovation is not for geniuses working alone; it is an activity that requires a team effort. Being innovative is a part to approach the new era.

I also founded Dwarves Ventures, the investment arms of Dwarves Foundation. We invested in a few startups that want to build next favorite things. One of our investment is Super Bits. It's a product team that dedicated to making software & tools for programmers and development team.

We are heading to the future

Throughout the years, we still believe that the best way to predict the future is to invent it. In the run to the future, we are continually working and exploring new technologies, frameworks and methodologies. While we actively involve in software development, we also have the opportunity to work with many startups, founders, business owners and software team, which make us one of the best witness to pragmatic innovation transformation.

The interest and area of knowledge keep expanding around technological know-how and practices to build sustainable businesses, in variety of

• Teamwork & Leadership
• Business and Organization Structure
• Product Development
• Software Design
• Digital Transformation & Automation
• Data-driven & Business Intelligent

And also

• Working with Startups
• Investment & VC Point of View
• Business Model Analysis
• Innovation and Methodology
• Everything else Science x Technology related

And The NeXT Bytes is a monthly memo where we want to share these experiences, observation and research summary. Together with my crew, we intend to provide a sense of the goings-on in the tech industry, with more than thousands subscribers who are founders, makers, software engineers, designers, product guys and technologist. As we are going to explore the future, we don't know what it holds, but the journey will be exciting.

The name The NeXT Bytes is inspired by Apple NeXTSTEP OS and also through the fact that Technology & Software continues to drive the world. Everything is running on code which consists of trillion of billion of zero & one bits combined. We want to look at the bright side of the future where the next generation of Bytes would be elegant, well-written and would make the world a better place.

Subscribing to this newsletter is a way keep up with these updates, with a message sent directly to your inbox.

Subscribe: https://tinyletter.com/nextbytes/

Dwarves Foundation

The company we founded in 2015 has turned 5 and reached its first milestone. It's about time to step down and let others take the throne.

• Transition: Some transitions are needed for the next generation to take over the company. Everything is quite in shape. The business model is firm. We have a great team of 50-ish, a growth rate of 60% since Day 1, a worth-to-pursue vision, a few missions ahead to accomplish, a playbook with all of our best practices, and a few good hires last year. I'm looking for a new CEO for Dwarves Foundation.
• Territory: With a good record serving customers in the last 5 years and everything are in place; the business expansion expects to happen both online and offline. Most of the time, we meet and work with our clients via the internet. The pattern works so far, but I believe there's still room for improvement. Why not try to take another business approach? I'm looking for business partners to explore the market that we haven't touched.
• Employee-owned company: Last year, we distributed company shares to the early employees and had the first batch of dividend pulled off. This year, we will continue to issue the ESOP to the rest privately. Every member who stays with the company for more than 2 years will have chances to earn company stakes.
• Fully automation & Data-driven operations: The best part of running your tech company? You have a vast workforce to try all the cool kinds of stuff. We have the data of every part of daily operations, from project development to personal development. All the hiring, branding campaigns, or even accounting & payroll adjustments should base on data. It will help reveal the hidden aspect that you've ever notice.
• A getaway office: It's my dream to have an unconventional office space where the dwarves can escape the city and hang around. One in the mountain and one near the beach. Still, a long way to go.

Dwarves Ventures

Taking the build capability to the step further, Dwarves Ventures is a micro VC that makes use of our knowledge, experience for years to help tech startups with business & financial models, pitch assist, product design, market testing, MVP & platform development. All the materials, metrics, and tractions to achieve before getting to series A funding round.

Last year, we made an investment into 2 local tech startups in Vietnam in exchange for 5 to 20 percent in equity. One major in Hospitality and one in Wholesale Marketplace. This year, among with the expansion of our core business and Craftsmanship Study Program, we hope to meet more exceptional founders.

Superbits

The internet used to be a fun place. Growing up, I couldn't find the same excitement. As per the prediction for the next decade, people tend to lean over the different & personalized, I decided to found the Superbits to help bring those excitement bits back. And we are not the only team want to do that, there's another that bring cool bits back to the internet for years. One of them: 100r.co

We started last year with a few macOS apps to help with the productivity boost. This year we will continue to look at this same topic.

A hedge fund for indie & retail investors

We build an autobot & apply quantitative methods into the global financial trading market, dedicated to producing exceptional returns. For the exceptional returns, I mean a few bucks for hundreds USD saving, LOL. It can't make us rich but can help make life easier, financially. It is still in beta testing, and I'm looking for friends who are interested in & also want to get the first taste. Please drop me a message at han@cashbag.xyz

Learn another language

I barely speak English. It's not so proficient, and I'm not a type to learn anything to excellence. So instead of getting a higher degree in English, I'd love to learn another language. Chinese & Japanese are on my list for now.

Be a dad

And finally, be a good dad. Learn to parent. I'm going to be a dad in about a month or two. I gave him a cool name, bought him a domain, hodl a few tokens in case they will go skyrocket. I'm still not ready for this, but let see what may come in the future.

With a different expectation in engineering standard, we rarely hire people outside of our circle. We handpick and recruit the individual whom we feel they are the one matching with the engineering-driven culture that we are pursuing. We also decided to hire high potential freshers and train them from scratch. It's costly to do such a thing, but we believe good things take time. That's the way we hire for culture (and values).

The culture we are pursuing is the combination between the unconventional spirit and the will to do the right things in every piece of our decision, not just follow the existing of which has been said for years. From the outside perspective, it seems to be ridiculous to develop such an organization:

• from gather people with like mind and build the organization we'd love to work at
• where judgments are fair and run by the right ideas
• people payout are equal to their contribution so they can make money and be cool at the same time
• people should commit to the quality, not the sales quantity
• the team members have time to think about the next problem they want to solve or can join the team on self-development progress.

It's like Utopia for software engineers and innovators.

The thought about an unusual business approach, high risk, and considerable chances to fail often appear in my head. But things are getting confident in me over time. There are few companies out there did the same thing, and they stood out.

Remember when Steve Job talked about why he didn't hire the professional managers? In the fast-paced industry like tech, the developer turned manager rule the works. The professional managers can't do crap about that. Managing at Dwarves Foundation is a part-time occupation, next to being involved with doing the work itself.

And running by ideas is the best way to hire great people.

Some companies care about the work output, not chairs.

Or when they accept the truth that planning is guessing.

I love the unconventional way they see and describe the world, not in the fascinating prism but the true nature.

We seek those kinds of people to join our team. The one which is distinctive, with a different approach and can see things in their bare form, know the truth, and be optimistic about the future are the right people we'd love to work.

Recently, an intern shared this post about quantum physics, time and it blew my mind. It reminds me of how lucky I am to have them in the team.

Tech industry is the destination and interference zone between sectors. It's the most fast-pacing environment and the future where human will put all the effort to push its boundary. The Dwarves are running along with the world, and we are welcome you to join us on this journey. We can't promise you the world, but we can guarantee you it will be a fun ride.

Software is changing the world

Software is all around us, yet few people think much about the many ways that software impacts the world every day. The history of computing is often said to start with the tactical problems engineers needed to solve in World War II, but it wasn't until 1941 that engineer Konrad Zuse designed a digital computer capable of using software to solve general problems. During the 1950s, standardized programming languages emerged from the need to reproduce old software on new hardware. By the 1960s, software - until then given away for free with new computers - was being produced and sold to end users. By the 1980s, software companies saw the potential in the user-friendly graphical interfaces we are now familiar with. Apple started producing operating systems in the mid-1980s and Microsoft in the early 1990s, leading to the era of convenient and fast software. Internet was invented in 1983 with cloud computing and big data era follow up in the next 20 years. Decentralization with p2p communication, blockchain and bitcoin are booming up in the last 5 years. Today, software is all around us.

Software is used by businesses to communicate worldwide. It is used to operate some of the most complex medical machines. It regulates nuclear plants, electrical grids, and other utilities that provide the basics of life. Of course, it is also behind the safe operation of more than 31 million commercial airline flights in the U.S. each year.

Software also helps make life convenient. For example, computer software has made it easier than ever to connect with friends all over the world using social networks. As software becomes more integrated into electronics and appliances, it will continue to simplify life's challenges. As an example, everyone is familiar with how much easier it is to drive from point A to point B thanks to on-board GPS software. Refrigerators can now notify owners about spoiled food; lights around town and in your home can brighten when they detect you walking in the dark; televisions can make suggestions and record your favorite shows based on your preferences.

Whatever the future holds, it is a good bet that software will remain a very important part of it. As computer software becomes more sophisticated, it will help people with more complex challenges. In the future, software may even help us to regulate and improve our own bodies! Today's wearable technology and implanted medical devices are just the beginning of what the next generation of software can do.

It's the pass to future. The performance and survival of a large number of organizations now depend on their ability to integrate digital at the heart of their business strategy. The world can't operate without software.

The Dwarf Principles

Our definition of Engineering Philosophy, the guiding ideas that help to shape up the way we think and work, to ensure the core values and to deliver quality softwares.

The performance and survival of a large number of organizations now depend on their ability to integrate digital at the heart of their business strategy. This manifesto documents 15 principles that, our team believes, are the cornerstone to creating exceptional digital products that reach their objectives and stand the test of time.

Engineering Drive

We build a company where software engineering discipline could shine, innovative and quality products are shipped and change the world for the better.

SYSTEMATIC DISCIPLINE

Software engineering is an engineering discipline that’s applied to the development of software in a systematic approach.

Not applying software engineering methods results in more expensive, less reliable software, and it can be detrimental on the long term, as the changes come in, the costs will dramatically increase.

ENGINEERS ARE NOT COMMODITIES

In every software, the engineering team is one of the most imporant factors to make it successful. Software is more of an artisanship, and software engineers aren't a replaceable cog.

People have an assembly line mindset left over from the industrial age. Don’t believe the one-size-fits-all interview process with whiteboarding problems. These serve to grind away the individuality and make us feel like an assembly line worker.

THE BEST IDEA WINS

If you have a great idea and the will to see it through, you can effect great change. Nothing is off limits—we’re constantly looking for improvements in our products, our processes, and our people.

All voices are equal here—we hire people to have an opinion and be creative. If your idea makes the most sense, that’s what we’re doing, regardless of your role or seniority.

We learned the practice from an A team, and it is beneficial by helping to strengthen the flat organizational structure.

The Craftsmanship

WELL-CRAFTED SOFTWARE

We humbly demonstrate our expertise by delivering quality software. We work toward perfection in every single piece that we produce. We are proud of the well-crafted software that we develop together. We do not tolerate preventable defects.

QUALITY PAYS

Good things take time. Quality must be the top priority. In software work, quality problems overwhelm everything else. When quality isn't managed, entire software projects are unmanageable. Software development is intellectual work. Crafting a high quality software requires not just lots of efforts from a team but also the disciplines and proper methods.

MIND THE DETAILS

Details matter. We believe small details equate to big success. As such, creating a product that charms users involves adjusting, refining, and perfecting, over and over again. This attention to detail makes all the difference and creates memorable user experiences.

CHOOSING THE BORING SOLUTION

Software development is complex enough by nature. When in doubt, go with the boring solution. Using such a boring solution means that you're using simple vocabulary, which greatly increases the chances of everybody understanding you. This will make it a lot easier for everybody to follow along.

THINK LONG-TERM

We do not believe in rushing for project and working overtime. We believe in working sustainably and balanced so that we are a happy bunch of sane workers. Software requires good brains to create good codes and good processes. We do not burn out.

APPLICATIONS NEED SOLID FOUNDATIONS

Quality products always rely on a solid foundation. There will be a lot of works running on days, weeks, months, and maybe even years building that application. This constant, never-ending maintenance and extension of an application means that its foundation becomes crucial. Much like with a house, it's not a clever idea to save some money by building just a cheap foundation.

NOTHING IS PERMANENT

Software moves fast. New technology has enabled us to create new things. The technology you used yesterday maybe deprecated today. Make sure you understand both the old technology and the new one before buying into the next new thing. New technology needs to provide actual value over existing solutions.

Minifesto

RUNNING LEAN

Lean philosophy regards everything not adding value to the customer as waste. In order to eliminate waste, one should be able to recognize it. Partially done work, extra processes like paperwork and features not often used by customers are waste. Rework or unnecessarily complex solutions are waste. Waiting for other activities, teams, processes is waste. Managerial overhead not producing real value is waste.

DELIVER AS FAST AS POSSIBLE

Make it work. Perfect is an enemy of good. Look for perfection, but not yet. First do it, then do it right, then do it better. Any sufficiently complex system cannot be built out of design, it has to be evolved. The shorter the iterations, the better the learning and communication within the team. The sooner the end product is delivered without major defects, the sooner feedback can be received, and incorporated into the next iteration.

AIM FOR SIMPLICITY

Simplicity is complicated. Simple is harder than complex. We have to write code for humans not machines. We want readability. Readable means Reliable. It's easier to understand. It's easier to work on. If it breaks, it's easier to fix.

EFFECTIVE > PRODUCTIVE

Being productive is about occupying your time—filling your schedule to the brim and getting as much done as you can. Being effective is about finding more of your time unoccupied and open for other things besides work. We don’t believe in busyness. We believe in effectiveness. Know your priority and do things that matter.

FAIL FAST, LEARN OFTEN

Don't be afraid of starting all over again. Evaluate your work constantly. Don't be afraid of throwing to the rubbish a project you've working on last months. When you start from scratch, innovation comes organically inspired by previous experiences. Evaluate your work constantly.

WE ARE HIRING

We are looking for more Dwarves joining us. Have the same DNA and want to build world class products with superb team? Find yourself a seat at: https://dwarves.careers

We build a dynamic environment where engineers can spend their time working with disruptive startups and be cool at the same time. Checkout engineering life at Dwarves Foundation: https://dwarves.careers/life/

Here's our cat

--

The web version: https://d.foundation/manifesto

Dwarves Foundation is a software development firm that based in South East Asia. Starting in 2014, we use cutting-edge technology to help tech startups, entrepreneurs and makers to deliver world-class software products.

The Dwarves of the Year

Many endeavors have significantly been made by our Dwarves to keep our boat moving over the past year. We have seen the sweat they drop. We have seen the effort they give. We have seen the time we spent together and we cannot stop ourselves treasuring those moments. It gratifies the team to eventually hold an award for the Dwarves of the year.

We understand that success does not come by accident. Breakthrough arrives after hours of working and trying. It pushes us through many considerations to finally reach to these three top-notch nominees among those remarkable hard works:

Huy Nguyen — Outstanding

Considered for his dynamic contribution, Huy distinguishes himself for being enthusiasm towards the work. His striking performance was shown throughout multiple products. Appears to be the frequent workaholic who dedicates his time more than others, Huy did achieve a remarkable growth. Beside successfully improving the internal competency, Huy is highly recognized for being a dedicated trainer for interns and co-workers.

Thanh Pham — Honorable Mention

Thanh differentiates his work performance during the process of development which assigned him the superior skills on visual and animation. Apart from being a devoted employee, he also plays an integral part of backing up the team and training front-end juniors. Nevertheless, Thanh finds himself hard to fit in with other Dwarves, which explains the reason his ability in leadership is still in need of improvement.

Hieu Nguyen — Honorable Mention

Along with achieving breakthrough change on technical skills and meeting deadline on time with high standard workability, Hieu is well known for being proactive and eager to learn new things. Hieu also proves himself as an adept for new Dwarves to look up and get feedback from. Though he truly give his best for the work, Hieu’s limited ability of teamwork and leadership still prevents him from being more outstanding.

As there is nothing that can help us measure the contribution you have put, we decided to conduct the award by different means. They are expected to claim the prize based on their titles both in cash and in kind, along with a certificate of recognition as a proof of accomplishment, as well as being honored on our Hall of Fame. Every single piece of trying helps us gradually expand the picture. Live long and prosper has been chosen as one of the mindsets to constitute our woodland from the very first day.

For the sake of that to happen, we understand that their benefit comes parallel to the team. So it will be dead wrong if you think there is a benchmark for the means of award. At Dwarves Foundation, recognition does not work that way. The more they contribute, the more guerdon they receive.

2018

2018 has been a fulfilling year for us with many achievements.

We adapted the new team structure; we redefined things we value.

We doubled the office space. We welcomed new dwarves to join us.

We scaled up from 15 to 40ish with all the smart people gathering around and commit to the dream of building our first global software firm.

We learn new ways to get things done; we live by that for a cutting edge product quality. And we wrap it up with the tedious belief of a better triumph.

Everything is just the beginning of our first chapters and it couldn’t be that great without you. I’m very thankful for all the contributions that you have made and looking forward to 2019 with all of you.

We are hiring

As we are expanding in 2019, we are looking for more Dwarves joining us. Find yourself a seat at: https://dwarves.careers

Read more at: Medium

Building an innovation startup requires lots of different things, and it is tough. Most of them have to deal with business development, legal, fundraising, team recruitment, and product development at the same time. Tech startups need to move fast and break things.

At some points, growing a startup needs a strong and experienced team behind. The software team that can help to design the system, design the database, produce the well-crafted software, keep the system stable, avoid the technical debt and deliver values is one of the critical pieces to solve the puzzle.

Another motivations for Dwarves Foundation was the lack of respect that service firms receive. Most software companies out there focus on digital transformation and consultancy. They do tricks. They hit and run. The codebase they produced is full of crap and it damages our pride.

This is where Dwarves Foundation comes in. Despite the fact that service firms scale linearly, their ultimate size is capped and small, they don’t have life-changing exits for their founders, we start Dwarves Foundation as we want to build things right. I’ve always felt that companies like Dwarves Foundation are more important to the economy than the mildly pejorative phrase used to describe them.

Dwarves Foundation is an innovation service firm. We have been building an organization with high standard software practices and business growth capabilities, helping tech startups, entrepreneurs and makers deliver their innovative software product since 2013.

We stand for the craftsmanship in software development. More than telling people how to do things, as a firm, we take responsibility for collaboratively creating the product of innovation with the client. We value the long-term partnership, and we brought the economic impact through massive product distribution and brought to the market by the clients.

We empower innovation with software craftsmanship. This is what we do here. It takes many forms, and we’re always working towards it.

The Dwarves

The story begins in Norse Mythology. After the executed of Ymir, the very first giant of the universe, by Odin has conceived a whole new universe. In the new world, Yggdrasill is a giant ash tree located at the center cradles the nine realms of the cosmos.

Dwarf is the small and misshapen creatures that originated as maggots from Ymir’s corpse. They dwell in the mountains deep down in the dark underground of Svartalfheim. Dwarves are wisdom, natural good at smithing, mining, and crafting. They are well known for being the best blacksmiths throughout the nine worlds, not only do they have natural abilities to craft weapons and jewelry. They are also excellent engineers and architects.

Dwarvish magic was fundamentally technological know how. They had an unusually high level of skill. There was no shimmering light around the Dwarves, just first rate workmanship. Dwarves greatly pride themselves in their craftsmanship, be it smithing or anything else.

The dwarf is an example of a creature who has the ability that surpasses the known world, presaging the rise of a universe beyond this physical realm. Whatever their origin, the dwarf’s existence plays a role in expanding the imagination.

Aspiring to create a positive breakthrough that can be able to rewrite the new world, we chose the name Dwarves Foundation as the commitment to the vision that we follow.

At our woodland, the Dwarves are encouraged to thoroughly assess and evaluate the product quality before handing it to the customers. By participate in every detail of the work, we take craftsmanship as one of the most fundamental factors of the career transformation for engineers. World-class products require world-class engineers and craftsmanship is what makes it done. Craftsmanship is what flows among the team spirit, or does not exist at all.

We choose innovation to be one of our core values that form ideas to affect the general society undoubtedly. Innovation is not for geniuses working alone, it is an activity that requires the team effort. Being innovative is a part to approach the new era. What that rewards, what can I say, can genuinely lead to significantly remodel the cosmo.

Empower innovation is the lifestyle we choose and we are always welcome the like minded people to join us on this journey. A network with all the people who want to change the world would be really awesome. Drop us a message team@d.foundation anytime.

As you and your cofounder (or cofounders) embark on your entrepreneurial journey together, it’s imperative that you all share the same vision for the purpose and future of your company. It’s easy to get caught up in the thrill of launching a potentially successful startup together, but you all must take the time to establish the existential foundations of the company, and as early as possible, to help prevent the possibility of a drastic falling out later on.

What Are Your Goals?

• Why are you creating this startup?
• What need will it fill?
• What will your initial product/service offering be?
• And what is your strategy for growing the company?

What Are Your Company Values and Philosophy?

Your company’s success depends on vision alignment (alignment between you and your investors, your employees, and your customers, etc.). Do you share the same priorities? Do you agree on what’s most important to you both personally and for the future of your company?

How Do You Measure Success?

• What do you and your co-founder(s) hope to get out of this business?
• How will you know if you’ve achieved your goals?
• If you don’t agree on the same goals, how will you know when you’ve achieved them?

"Discussing these issues with your co-founder could get uncomfortable, create rifts, or even uncover deal-breakers. If you are able to successfully have these difficult conversations, this is a testament to your partnership and to the strength of your relationship -- and will serve as a solid foundation from which to grow your business." - David Ehrenberg

Working Styles and Culture

Once you and your cofounder have laid down the aspirational and philosophical groundwork for your startup, this is also the ideal time to determine what kind of working environment best complements the vision of your startup.

• What 3 words best describe the startup culture you want to create (e.g. open, hard-working, eccentric, etc.)? Pro-tip: If you’re really serious and far along go visit few office spaces together to get a sense of what each of you likes work environments wise and why.
• What values do we want to instill in our employees?
• If you could pick 2 things to change about our company, and two things to bring with you from your previous experience, what would they be and why?
• How much equity are we allocating for future employees?
• What should we look for in our first 5 hires?
• Describe your ideal working style.

Legal Decisions & Definitions

General Questions

• Is the percentage ownership subject to vesting based on continued participation in the business?
• If one founder leaves, does the company or the other founder have the right to buy back that founder’s shares? At what price?=
• What salaries (if any), are the founders entitled to? How can that be changed?
• How are key decisions and day-to-day decisions of the business to be made?

Basic Legal Definitions

Harroch's article also explores numerous basic legal terms associated with launching a startup, all of which you and your business partner should familiarize yourselves with.

• Confidentiality Agreements - These are also referred to as Non-Disclosure Agreements or NDAs. The purpose of the agreement is to allow the holder of confidential information to share it with a third party.
• Copyright - A copyright gives the owner the exclusive right to make copies of the work and to prepare derivative works (such as sequels or revisions) based on the work.
• General Partnership - If there is more than one founder, a general partnership is often chosen as the legal form of business entity.
• Patent - A patent gives its inventor the right to prevent others from making, using, or selling the patented subjected matter described in words in the patent’s claims.
• Service marks - Service marks resemble trademarks and are used to identify services.
• Tax Incentive - Depending on the nature of the business, various tax incentives may be available, such as renewable energy tax credits and investment tax credits.
• Trademark - A trademark right protects the symbolic value of a word, name, symbol, or device that the trademark owner used to identify or distinguish its good from those of others.
• Trade Secret - A trade secret right allows the owner of the right to take action against anyone who breaches an agreement or confidential relationship or who steals or uses other improper means to obtain secret information.

Include a Vesting Schedule When Issuing Shares to Co-founders

When you create a vesting schedule, this means that the co-founder will earn their shares over time and protects you and the company if that a co-founder leaves the company or doesn't pull their weight. The standard vesting period is four years, with monthly vesting of shares. Unvested shares should be subject to repurchase by the company if the co-founder leaves the company.

Protect Your Valuable Intellectual Property

If intellectual property is a vital element of your business, it's important to protect that IP during the formative stages of a company. You can address this issue by relying on patents, trademarks, copyrights, and trade secrets to protect your valuable IP. Another step you can take is requiring all co-founders and any third-party developers to assign to the company their rights in IP they created and that is utilized by the company. Doing this will help prevent trouble if a co-founder leaves the company and takes a crucial patent with them.

How to Split Equity

Ideas are Valuable

If you brought the original concept to the table, increase your share holdings by about 5 percent. While execution is more important in the long run, whoever conceived the original idea deserves a little extra credit.

That First Step is a Doozy

Bringing something of value to the company during its formative stages – like a filed patent (not a provisional), a compelling demo, an early version of the product, or something else that means much of the work towards financing or revenue is already done – you should receive a considerable part of the equity.

Full Time Commitment is Expensive

Bottom line, if you’re working more, then you’re risking a lot more if the project fails, which means that you are entitled to more if the project succeeds. Also, keep in mind that part-time cofounders are a big minus to someone considering an investment, so choose your partners wisely.

The CEO Gets More. Always.

Splitting equity equally means that no one controls the company more than anyone else. But if that’s the case, than having a CEO is useless, as well as having any form of upper management. So, whoever is the designated CEO should get another slightly more equity. If you think that’s unfair, remember that market rate for a great CEO is higher than market rate for a great CTO, which means that’s how it is everywhere.

Reputation Counts

If you’re a beginning entrepreneur and your partner is an experienced founder with an established reputation, they deserve more equity. If that founder has an expansive network that benefits the company, they deserve more equity. If that founder can help secure more funding for your company, they deserve more equity.

"The question of equity brings out the most fundamental differences, perceptions, and values in an aspiring startup. In fact the equity question, more than any other, may strangle a young company before it can even get started. And that’s a damn good thing." - Dan Shapiro

Final Thoughts

Yes, talking about such topics as company roles and vision and equity and the like can be uncomfortable among founders. However, these discussions are vital to a successful partnership, as well as a successful startup, and must be held before any of you invest too much time, energy, and money into a potential company. Keep in mind that whoever you decide to launch a company with, you all will have to make countless difficult decisions once your company is actually up and running. If you take nothing else from this blog post, at least follow the bit of advice below:

"Choose co-founders the way you would choose a spouse. The reality is that you will, at least in the early days, spend far more time with your co-founders than your partner." - Danielle Newnham

Source: fi.co

Being a part of the tech community, realizing a few issues, also wanting to contribute a bit, this blog post is my precious and is a part of the whole series to improve the quality of next generation of developers.

Below is the short list of recommended things to do to contribute to the tech community.

Start by listening

Walking into a project and saying “Hi, here’s what I think this project should be doing” is usually not taken as a good thing. Some projects may welcome that sort of approach, but if the project has been running a while, the chances of that attitude being embraced are small. Listening is the best way to know what the project needs.

Join a mailing list

For a large scale and open project or community that involve many people, communication through a mailing list is one of the most effective ways to not distract others and good for you to follow the entire discussion.

Some of the mailing lists I followed over the past two years.

• Viet Infosec
• golang-dev
• golang-nuts

Follow a blog

Elite developers blog are great knowledge sources that you should follow and learn from them. Some of the rock stars they don’t have their blog. Instead, they use Twitter for daily updates.

• Dave Cheney: Dave Cheney | The acme of foolishness
• Dan Luu: Dan Luu
• Rob Pike: command center
• Golang: The Go Programming Language Blog

Join online discussions via Slack or IRC

Most of the communities have their channel to keep in touch and discuss the project or things related to the community with other members.

IRC is one of the most popular tools that have been used by many projects, e.g. Python, PostgreSQL, OpenStack. IRC is free software. You need to download a client and ask for the node address to log in.

Beside IRC, there are several modern communication platforms. They are commercial products that serve the teamwork very well. Some with a free plan has been applied to the new community: Gitter, Slack, Discord. Also, new members are always welcome there.

• Reactiflux: Discord
• Golang: Slack
• Sails: balderdashy/sails - Gitter

Some communities in Vietnam I take participation in

• Golang Vietnam: http://golang.org.vn
• Ruby Vietnam: http://ruby.org.vn
• Grokking Engineering: http://grokking.net

Participating

Organizing events

The event organizer is a difficult job and very time consuming, but it’s the most critical factor to keep the community alive. People might not find it necessary as it depends on the interest. During the days in 201x, more and more events were held by the various scale of organizations and companies. Some activities that you may find

• Technical Meetup (Golang, Ruby, Geeky, Grokking)
• Product Meetup
• Design Workshop
• Mobile Day
• Web Summit

Sponsor an Event

Sponsoring a participant in a program can be a great way to show your support, especially when you have your friends or employees participating in that event.

Usual the local events are just at a small scale from 50 - 100 participants. If they are meetup or workshop event, most of their needs are a venue to organize or food and beverage or a small amount of money for operating costs.

Sharing your knowledge

In every event, if you can’t afford to sponsor an event or have enough time to be an organizing member, you still can give your hand to the community by sharing your thoughts, your knowledge to other people.

Answer a question The best way to help build the community is by helping others. Answering someone questions especially when he is just getting his feet wet is very helpful for him. I see a lot Viet Community doesn’t have that culture. They usually piss off the newbies and don’t want to give out their hands.

Write a blog post

If you’ve got a blog, write about your experiences with the project that you’re using. Tell about a problem you faced utilizing the software and what you did to solve it. You’ll be helping in two ways, both by helping keep the project on the minds of others around you and by creating a record for anyone else who has your problem in the future and searches the web for the answer.

Contributing to Open Source

Open source software (OSS) is distributed under a licensing agreement which allows computer code to be shared, viewed and modified by other users and organizations.

Alternatively, in slightly more user-friendly language, open source software is available for the general public to use and modify from its original design free of charge. What it means is that a piece of software can evolve and be iterated upon by other developers anywhere in the world. Ideally, this says that the software is improved over time, but it can often take plenty of exciting twists and turns with all of that evolution and can change form and shape entirely. ¹

Diagnose a bug

Bugs are often poorly reported. Building an attitude to help narrow down the problem make it easier for the developers to fix it. Whatever you discover, add it to the ticket in the bug system for all to see.

Fix a bug

Finding an interesting bug in the ticket system and try to fix it is the best practical way to contribute to the open source project. Remember to follow the guideline and during your working period, document whatever you know to help the later contributors. Write some tests if you can.

Write a test

Adding the test to the open source project will help to improve the quality and make it more stable. In some cases, test cases and test suites are more like the documents for the project.

Start Up

Here CEOs are:

• Doers, the 'Jacks and Janes' of all trades.
• Decision makers

Initial Growth

CEOs must:

• Learn to delegate
• Learn how to attract and recruit the right people
• Set the company direction

Rapid Growth

CEOs need to:

• Hire people with more knowledge than themselves in the key business functions
• Get the team to function as a 'team', to plan and communicate

Continuous Growth

CEOs need to:

• Become strategic innovators & change catalysts
• Lead the company culture

Know how to write good commit message

Source: http://chris.beams.io/posts/git-commit/

Have you ever read some repos with commit messages like above?

While many repositories' logs look like the former, there are exceptions. The Linux kernel and git itself are great examples. Look at Spring Boot, or any repository managed by Tim Pope. The contributors to these repositories know that a well-crafted git commit message is the best way to communicate context about a change to fellow developers (and indeed to their future selves). A diff will tell you what changed, but only the commit message can properly tell you why.

Being known that, a project's long-term success rests (among other things) on its maintainability, reviewing others commits and pull requests is also the big reason that you should write great commit messages.

In the post, the author wants to address the most basic elements of keeping a healthy commit history: how to write an individual commit message. You can checkout the source article or just follow the seven rules below and you're on your way to committing like a pro

1. Separate subject from body with a blank line
2. Limit the subject line to 50 characters
3. Capitalize the subject line
4. Do not end the subject line with a period
5. Use the imperative mood in the subject line
6. Wrap the body at 72 characters
7. Use the body to explain what and why vs. how

Git branching model

Gitflow

Inspired by Vincent Driessen's branching model, git-flow are a set of git extensions to provide high-level repository operations for it. Git-flow is a merge based solution. It doesn't rebase feature branches.

• Checkout gitflow cheatsheet: http://danielkummer.github.io/git-flow-cheatsheet/
• Apps that support gitflow:
  • Source Tree: https://www.sourcetreeapp.com
  • Git Tower: https://www.git-tower.com

Note: Maybe after working for a long time with merge based Gitflow, you will find your git log a little bit confusing and look like that:

Please take no worries about this, because there is still a part about git rebase. For now, you can continue to read the article GitFlow considered harmful to know more about the author issue.

Gitflow pitfall

• It makes the project's history completely unreadable with the --no-ff flag. The --no-ff flag prevents git merge from executing a "fast-forward" if it detects that your current HEAD is an ancestor of the commit you're trying to merge. A fast-forward is when, instead of constructing a merge commit, git just moves your branch pointer to point at the incoming commit.
• The master/develop split is redundant.
• It's needlessly complex. And people make mistakes and break them by accident.

The Anti-gitflow

• There is only one eternal branch - you can call it master, develop, current, next - whatever. I personally like "master", and that's the name I'll use in the rest of the description, as it's convention by now in the Git world and immediately conveys its purpose.
• All other branches (feature, release, hotfix, and whatever else you need) are temporary and only used as a convenience to share code with other developers and as a backup measure. They are always removed once the changes present on them land on master.
• Features are integrated onto the master branch primarily in a way which keeps the history linear. You have a lot of leeway in how you want to enforce this. You can make it simply a convention that developers are encouraged, but not forced, to follow. On the other side of the spectrum, if you use something like Gerrit to manage your Git repositories (which I recommend, even if you don't practice code reviews - the permission system is fantastic, and if you ever decide you want code reviews, it'll be very easy to start doing them), you can set up permissions in such a way that actually forbids pushing merge commits to master, and that way ensure linear history.
• Releases are done similarly to in GitFlow. You create a new branch for the release, branching off at the point in master that you decide has all the necessary features. From then on new work, aimed for the next release, is pushed to master as always, and any necessary changes are pushed to the release branch (in my opinion, it's an anti-pattern and a huge red flag if your release requires separate commits to work, but that's a topic for another article - for simplicity, let's assume you can't or don't want to change that). Finally, once the release is ready, you tag the top of the release branch. Then, because there is one eternal branch, there is only one way to get your release to be versioned permanently - and that is to merge the release branch into master and push that changed master. After that, all the changes that were made during the release are now part of master, and the release branch is deleted.
• Hotfixes are very similar to releases, except you don't branch from an arbitrary commit on master, but from the release tag that you want to make the fix in. Again, work on master continues as always, and the necessary fixes are pushed to the hotfix branch. Once the fix is ready, the procedure is exactly the same as for a release - tag the top of the branch creating a new release, merge it into master, then delete the hotfix branch.

Pull Request

Pull request is a feature that makes it easier for developers to collaborate. Pull request is a mechanism for a developer to notify team members that they have completed a feature. Some tricks to make Pull Requests more awesome for your project:

• Open a Pull Request as early as possible: Pull Requests are a great way to start a conversation of a feature, so start one as soon as possible- even before you are finished with the code. Your team can comment on the feature as it evolves, instead of providing all their feedback at the very end.
• Pull Requests work branch to branch: No one has a fork of github/github. We make Pull Requests in the same repository by opening Pull Requests for branches.
• A Pull Request doesn't have to be merged: Pull Requests are easy to make and a great way to get feedback and track progress on a branch. But some ideas don't make it. It's okay to close a Pull Request without merging; we do it all the time.

Hint: Based on an article Type of Pull Request, there are 6 types of PR. But WIP pattern is the one that is using by lots of teams and companies. It follows the mantra of "Open a Pull Request as early as possible".

Doing Code Review

Source: https://github.com/thoughtbot/guides/tree/master/code-review

Everyone

• Accept that many programming decisions are opinions. Discuss tradeoffs, which you prefer, and reach a resolution quickly.
• Ask questions; don't make demands. ("What do you think about naming this :user_id?")
• Ask for clarification. ("I didn't understand. Can you clarify?")
• Avoid selective ownership of code. ("mine", "not mine", "yours")
• Avoid using terms that could be seen as referring to personal traits. ("dumb", "stupid"). Assume everyone is attractive, - intelligent, and well-meaning.
• Be explicit. Remember people don't always understand your intentions online.
• Be humble. ("I'm not sure - let's look it up.")
• Don't use hyperbole. ("always", "never", "endlessly", "nothing")
• Don't use sarcasm.
• Keep it real. If emoji, animated gifs, or humor aren't you, don't force them. If they are, use them with aplomb.
• Talk synchronously (e.g. chat, screensharing, in person) if there are too many "I didn't understand" or "Alternative solution:" comments. Post a follow-up comment summarizing the discussion.

Having Your Code Reviewed

• Be grateful for the reviewer's suggestions. ("Good call. I'll make that change.")
• Don't take it personally. The review is of the code, not you.
• Explain why the code exists. ("It's like that because of these reasons. Would it be more clear if I rename this class/file/- method/variable?")
• Extract some changes and refactorings into future tickets/stories.
• Link to the code review from the ticket/story. ("Ready for review: https://github.com/organization/project/pull/1")
• Push commits based on earlier rounds of feedback as isolated commits to the branch. Do not squash until the branch is ready - to merge. Reviewers should be able to read individual updates based on their earlier feedback.
• Seek to understand the reviewer's perspective.
• Try to respond to every comment.
• Wait to merge the branch until Continuous Integration tells you the test suite is green in the - branch.
• Merge once you feel confident in the code and its impact on the project.

Reviewing code

Understand why the change is necessary (fixes a bug, improves the user experience, refactors the existing code). Then:

• Communicate which ideas you feel strongly about and those you don't.
• Identify ways to simplify the code while still solving the problem.
• If discussions turn too philosophical or academic, move the discussion offline to a regular Friday afternoon technique - discussion. In the meantime, let the author make the final decision on alternative implementations.
• Offer alternative implementations, but assume the author already considered them. ("What do you think about using a custom - validator here?")
• Seek to understand the author's perspective.
• Sign off on the pull request with a 👍 or "Ready to merge" comment.

Git templates

To make things easier, we have adopted Issue template and Pull Request template that we think they are great to help the team to improve the productivity

https://gist.githubusercontent.com/tieubao/2a9fc10be45a67ab315ef3f8ead6530d/raw/e99d04268bf83389f4f728f386f79d9da3132480/issue-template.md

View the gist

https://gist.githubusercontent.com/tieubao/98a83f179d06fe3e33e4dfe4f1395904/raw/4cd5eaa3586503c9a89b7cac34886e2769db01d1/pr-template.md

View the gist

^{And finally, Atlassian has a full tutorials from scratch, you can find it at: https://www.atlassian.com/git/tutorials/what-is-version-control}

I also find that Google Golang is interesting and it might be useful for us later. I bet my investment on it and found Golang Vietnam, a network of Golang Developers in Vietnam.

Based on some connections with friends in Singapore, I start asking people about other software businesses. And begin to find my first early member. I named a team Dwarves Foundation. Dwarf is the small and misshapen creatures in Norse Mythology that are wisdom, natural good at smithing, mining, and crafting. My plan is to provide Tech Partner service to ventures and startups.

Our values

We are a team of geeks, hustles and startup veterans. We live around the world but most of us based in Saigon, Vietnam. We are (forever) young and always eager to learn. We have passion and experience in making cool products, esp. cloud and mobile apps. We want to help entrepreneurs solve real problems using our approachs and solutions.

• Customer first: We provide the service with high quality and no latency response time. Customers have to be happy.
• Geeky style: We can do anything, wear multiple hats, take multiple approachs from official to tricky way to achieve the goal.
• Teamwork: Synchronisation and Collaboration are the most important key things. You can read this topic: It's hard to become a team member. We apply agile process to keep our spirits stick together.
• Proactive: Pick your most productivity time to work. You need to figure out yourself what you want to do and what you want to contribute aligned to the team goal as a dwarf in the tribe. We are too busy to tell you.
• Growth and sharing: You can learn another skill from other teammates. We are happy to share it to you. And we believe that working hard and improving yourself everyday will make you paid back later. Read this topic to keep yourself motivated.

Our services

• Startup Factory: Our woodland is the trustworthy place where lots of ideas are validated, incubated, developed, iterated until product-market fit simultaneously and for successful ones, we turn them into new businesses. The formula repeats on its own. Moreover, we also provide startups with hands-on mentorship and seed investment programs, usually in exchange for equity.

• Development Lab: Our woodland is the trustworthy place where founders could come and acquire expertise for their business models. We offer a technical partnership that takes over their whole systems and applications from development, operation to maintenance stages. We are backed by a talented, ambitious and technology-heavy workforce with years of experience. Consequently, we guarantee world-class quality for delivered products across all platforms (Web, iOS, Android).

• Talent pool: Our woodland is the trustworthy bridge for the founders who are outsourcing products to connect with talented developers in Vietnam. We guarantee the most competitive prices among competitors in local market. It is the outcome of continuously building a wide network of trust between founders and talents. The price is worth it!

Workflow at Dwarves Foundation

For project management

We use Trello with Kanban theory to organize tasks. Tasks will be flew from left list to right list. We also organize lists into Scrum steps. So this will be liked:

• Sprint Planning
• Current Sprint
• In Progress
• Blocked
• Testing
• Bugs Report
• Approved

For each project, we will have Sprint planning meeting for Project Manager to explain project details to project members. User stories will be converted into cards or tickets and added to Trello list > Sprint Planning.

Usually, one sprint is about 1 or 2 weeks, we have weekly meeting to break user stories into tasks and add them to list Current Sprint. It's also our target for this week, we have to get in done. This time, cards need to have requirement and non requirement specification. And sometimes, if this task has some special requirement that developers need to care about, the Project Manager need to add Acceptance Criteria.

As a customer, you are granted permission to access Trello Board to give feedback or be a tester. And most of my customers are happy with it.

The template for this workflow can be found at https://trello.com/b/WYgcFBgl/sprint-template

For source code management

We use git and GitLab. It's more like GitHub but for enterprise. You can have one by downloading and deploying it yourself.

We apply Gitflow and Merge Request (some people may call it Pull Request) between developers to gain some benefits from it:

• Can deliver anytime because branch master is always stable.
• Quality source code: always review it after it's merged into branch develep
• High efficiency collaboration between team members.

There's another article about it on Atlassian site: https://www.atlassian.com/git/tutorials/comparing-workflows/feature-branch-workflow

Project Manager will be the one that init the repository on Git with some imporatant informations. For every ticket on Trello, developers need to create one issue in GitLab, create new feature branch and start the implementation on it. The git commit command must attach with one or more than one issue.

After that, one merge request will be created and the person who has responsibility to review this request need to check over the source code then Accept or Reject the Merge Request.

This card will be moved to list Testing, QC will be assigned to test this feature and so on.

For Communication

We use Slack as the main hub for all informations, from team meeting, hangout, manage tasks and source code ...

Slack support lots of methods to add integration. So the powerful it can be depends on what you integrate into it.

Finally, at the end of the day, we do daily meeting via hangout or face to face at the office to summary what we have done today and what we plan to do tomorrow. The project manager will be the one to write it down and make weekly report to customer.

All the processes out there are just to make the team stick together and development plan works. All team members need to understand their roles, team vision and know how to make things go on the right tracks.

Read more about Teamwork.

• About us: http://www.dwarvesf.com
• Github: https://github.com/dwarvesf
• Hiring: https://github.com/dwarvesf/WeAreHiring

The purpose of this post is to not just share with you what we did and the process we went through, but to also give you the tool we built to help us along the way.

Yes, it can be uncomfortable. Get over it.

I’ve seen far too many founders put this off because it’s an uncomfortable conversation. The reality is, if you’re not comfortable talking about uncomfortable things with your co-founder(s) ... you’ve got bigger problems. This relationship can’t be one of secrecy or procrastination. The nature of an entrepreneur is to take something on…head on…and right now. This equity split conversation is one of the first (of very many more) uncomfortable conversations that you’ll have with your co-founder, and it’s a great signal for how well you’ll work through future situations.

This relationship can’t be one of secrecy or procrastination. The nature of an entrepreneur is to take something on--head on--and right now.

So, we started digging and found countless resources talking about how equity should and shouldn’t be split among founders. The problem (with any advice) is, everyone’s got an opinion. Many of those opinions of course are based on their previous experience which may or may not be related to your situation, how far along the business is, and countless other variables. So, with all of these opinions and calculators out there, how did we come to terms with it?

We used them all.

Then we built our own tool to leverage them, and dove in.

It’s not about you.

It’s important to realize that this isn’t entirely about you. Through this process, we learned things about each other we didn’t know. We learned more about each other’s skill sets, our pasts, projects, accomplishments, and what we could each truly bring to the table. Sure, it’s a little about you. But it’s got to be about your co-founder(s) as well... so you need to have an open and receptive mind.

What was the end result for us? We were both very happy with the outcome, we learned a TON about each other that we didn’t know before, and walked away from the process more comfortable about working together than ever.

"Alright already. Give me the tool!"

Bryan and I each took our tool and started mapping out what aspects we felt were important to our business, and what we felt we each brought to the table. We did this independently of each other over a day or two. Then, we sat down and went through everything item-by-item. That is where the magic happens.

The spreadsheet has 5 different calculators in it, and a final box that averages everything out among all 5. Hopefully it’s intuitive enough for you to use. Any questions, hit me up in the comments!

Source: AL BSHARAH

Many entrepreneurs think that each founder should own equal shares. This can be problematic, for many reasons.

Here are a few things to think about when dividing ownership and founders stock.

• Who is bringing the funds to the table? Money is important and without initial funding, you can't get a business off the ground. But is the bank-roller entitled to a larger proportion of the shares? The decision will depend on how much money he or she is putting in and what his or her additional roles are in the company.
• Whose idea was it? There is some value to put on the original idea. But simply coming up with the idea shouldn't give majority ownership to the founder. Was the idea patented? A patented idea carries more tangible weight than an abstract idea.
• Who will be doing the lion's share of the work? Set agreements on day one for who will be contributing work. One person may be contributing valuable managerial labor while another one might be designing important elements.
• What are your business projections? This is an important question because it helps you figure out who is in the company for the long haul. Which brings us to the final point.
• Have vesting restrictions. Your stock agreements should have provisions stating that no founder can pull out stock in the company until the lapse of a certain period of time. The last thing you want is for someone to put in the minimal and cash out early at the same proportion as the founders who are toiling away daily.

Equity splitting between founders is very important and can be the source of much business litigation in the future. Remember that the startup equity sharing can also bring control issues and voting issues. You need to be careful who has control and who has voting rights in the company as well.

Also keep in mind that not everyone needs to be an "owner." You don't want too many cooks in the kitchen. See if any of the initial contributors can have a different role, perhaps as a key employee with a different class of stock ownership.

Source: FindLaw

Nguồn: http://ghichep.ninhnv.com/

Cảm giác thế nào khi bạn tham gia gây dựng một công ty startup? Câu trả lời của Paul Dejoe trên Quora với hơn 1400 votes (hiện tại là khoảng 5800 votes) đã tóm gọn gần như đầy đủ các cung bậc cảm xúc của những người làm startup.

Cảm giác thế nào ư? Mỗi đêm bạn đều trằn trọc khó ngủ. Ngày cuối tuần chẳng còn nghĩa lý gì nữa. Các vòng đầu tư cũng chẳng giúp bạn nhẹ nhõm hơn được gì. Vì điều đó có nghĩa là càng có nhiều người trông cậy vào bạn mang lại lợi nhuận gấp 20 lần số tiền họ đã đầu tư vào bạn. Và thật là khó khăn để dứt bỏ các suy nghĩ về công ty. Ngay kể cả TV, phim ảnh hay các kỳ nghỉ lễ cũng trở nên nhàm chán khi mà tương lai, vận mệnh của công ty bạn đang ở đâu đó trong Inbox hay kết quả từ một bài test A/B bạn vừa quyết định chạy thử.

Bạn cảm thấy thật tội lỗi khi làm gì đó bạn thích ngoài công việc ra. Trải qua hàng năm trời vật lộn với cuộc chiến nội tâm, bạn mới nhận ra rằng, giữ cho cuộc sống "cân bằng" là cả một nghệ thuật. Nó quan trọng chẳng kém các kỹ năng bạn vốn hằng ao ước.

Bạn bắt đầu cảm thấy sáng tạo có giá trị dường nào và bạn buộc lòng phải suy nghĩ một cách khác biệt, không chỉ để thắng cuộc mà còn để nhìn ra cơ hội tốt nhất. Bạn nhận ra những ý tưởng tốt nhất nảy sinh không phải là khi bạn dán mắt vào màn hình. Những trò giải trí tiêu khiển nhẹ nhàng lành mạnh lại mang lại hiệu quả tức thì không ngờ đến.

Bạn bắt đầu thấy nể phục mấy con vịt. Quẫy đạp như điên dưới nước mà phía trên vẫn phải tìm cách nhẹ nhàng, ung dung khi mọi người ngước nhìn. Bạn thấm thía một điều rằng nếu bạn đánh mất đi cá tính, phong thái của mình, tức là bạn thua cuộc.

Bạn luôn luôn tự hỏi liệu mình có đang thay đổi thế giới ngày một tốt đẹp hơn? Hay người ta sống có tốt hơn từ ngày biết đến bạn không?

Bạn sáng tạo và khi bạn có một ý tưởng, dường như chẳng có gì có thể cản trở bạn cho đến khi bạn biến được nó thành sự thật. Bạn có cảm giác này đơn giản là vì bạn không thể làm khác đi được. Bạn bắt đầu cảm nhận cụm từ "entrepreneur" gần gũi hơn. Thật khó để giải thích cho bạn bè rằng không mạo hiểm như bạn chẳng qua là vì trong đầu họ chất đầy nỗi lo sợ không dám thúc đẩy bản thân hành động hay mang tất cả những gì đang có ra để chiến đấu cho dù thật bại luôn rình rập hàng ngày. Bạn bắt đầu biến các cuộc chuyện trò có liên quan thành câu chuyện làm thế nào có thể khai thác các cơ hội thành lợi ích nó mang lại. Những người gần gũi với bạn sẽ nhìn vào những gì bạn quan tâm theo một cách hoàn toàn khác bởi vì họ chẳng hiểu gì cả. Bạn không trách cứ gì họ. Họ không thể hiểu nếu họ chưa từng tự mình làm điều gì đó tương tự. Đó là lý do tại sao bạn cứ đi tìm cách thuyết phục người khác trở thành Entrepreneur như bạn. Bạn cảm thấy có được phần thưởng xứng đáng khi giúp đỡ các entrepreneurs khác. Đây là email của tôi: paul@ecquire.com. Hãy cho tôi biết tôi có thể giúp gì cho bạn không.

Việc của bạn là tạo ra một tầm nhìn, một văn hóa, đưa đúng người lên chiếc xe cùng bạn và truyền cảm hứng cho họ. Khi bạn nhìn đồng đội của mình tin tưởng vào tầm nhìn đó, cũng nhiều chẳng kém gì bạn, và tin tưởng bạn sẽ luôn làm đúng, nó là cảm giác không thể diễn tả nổi. Nỗ lực làm việc hơn người theo cấp số mũ luôn khiến bạn ngạc nhiên. Đó là lý do tại sao tìm đúng đồng đội là điều khó khăn nhất nhưng cũng là điều quan trọng nhất. Bài học này sẽ ảnh hưởng đáng kể đến cuộc đời bạn sau này. Bạn sẽ không còn tìm cách giữ mọi thứ bình bình nữa vì bạn biết điều gì có thể xẩy ra khi bạn kiên trì mãnh liệt chiến đấu cho những gì tốt đẹp nhất và tìm thấy những cộng sự tuyệt vời. Sẽ chẳng còn là vấn đề khi thẳng thắn với mọi người mà không sợ làm tổn thương họ.

Bạn bắt đầu nhận ra rằng bạn là một lãnh đạo và bạn phải dẫn dắt hoặc bạn không thể theo được nữa. Bạn gạt đi những lời chào mời gạ bán vì bạn cần làm chủ cuộc chơi và bạn cảm thấy rằng các đồng đội của bạn là những người tuyệt vời nhất thế giới. Bạn có thể làm bất cứ thứ gì một cách chăm chỉ, cần mẫn. Từ bỏ không phải là một lựa chọn.

Bạn phải sẵn sàng ngủ lại công ty và thấy thoải mái với việc đó. Bạn có thể cười vào mọi thứ vì khi bạn nghĩ về những điều tồi tệ hơn có thể xẩy đến với công ty mình, thực tế là nó hoàn toàn có thể sẽ xảy ra. Hãy tưởng tượng bạn làm một cái gì đó trong suốt 2 năm trời và sau đó đổ sông đổ bể cả chỉ vì một sai lầm nhỏ vào một ngày nào đó. Bạn nhận ra rằng trong khi đồng đội của bạn vui vẻ và lúc nào cũng có thể cười cợt rằng bạn sẽ không thể chết được, thì sự thật lại ngược lại: bạn học cách trân trọng từng chặng đường đi và hướng đến tương lai trong từng việc bạn làm hàng ngày ngay kể cả những lúc khó khăn nhất. Bạn sẽ nghe người ta nói rằng đừng để quá tụt dốc khi mọi thứ tồi tệ và cũng đừng quá phởn chí khi mọi sự đang tốt, và bạn thậm chí còn đi khuyên người khác những điều tương tự. Nhưng bạn sẽ không bao giờ chấp nhận sự lờ đờ, chẳng bứt lên mà cũng chẳng kém đi vì điều này không thú vị chút nào. Ngay kể cả khi mọi thử đảo lộn hoàn toàn những gì bạn dự định thì cũng là một điều đáng để ăn mừng. Tự nhiên bạn lại cứ thích đâm đầu vào các thử thách khó nhất chỉ vì có một mối liên hệ trực tiếp giữa độ khó của công việc với cảm giác sung sướng khi làm những điều tưởng chừng không thể.

Bạn nhận ra rằng sẽ thú vị hơn nhiều khi bạn không có tiền và tiền đôi khi lại là thứ tồi tệ nhất là khi lấy nó làm mục tiêu cá nhân. Nếu bạn đủ may mắn để cảm thấy như vậy, đó thật sự là một cảm giác gần với sự bình yên vì bạn nhận ra những gì bạn làm là thử thách và cũng là công việc bạn yêu quý. Tài sản của bạn là sự tự do, chủ động, trách nhiệm và sự công nhận. Những thứ này cũng sẽ là những tài sản giá trị mà những người bạn muốn chiến đấu cùng cũng tôn trọng.

Bạn cảm thấy như thể những ông bố bà mẹ với khách hàng và họ sẽ không bao giờ hiểu được bạn yêu họ như thế nào vì chính họ là minh chứng cho việc bạn không điên rồ. Bạn muôn ôm lấy tất cả bọn họ. Và họ có ý nghĩa như là cả thế giới đối với bạn.

Những gì học được phần lớn là từ sự tự trải nghiệm, nhiều hơn bất cứ yếu tố bẩm sinh nào của một Entrepreneur. Bạn nhận ra rằng bạn cần làm gì khi nhận những cú đấm tả tơi vào mặt rất rất nhiều lần. Bạn nhận ra rằng điều bạn cần làm là khi chẳng có ai để ý và chẳng có ai nhìn ra. Bạn nhận ra rằng bạn kém đủ mọi thứ, và thật may mắn nếu bạn giỏi một kỹ năng nào đó. Và thứ duy nhất tuyệt vời có lẽ được là chính mình. Đó cũng là lý do bạn không bao giờ thỏa hiệp. Bạn học được quyền lực và vị thế có thể gây nghiện đến như thế nào và vì sao nó lại có thể tha hóa nhiều người đến vậy.

Bạn sẽ vô cùng biết ơn những quãng thời gian tồi tệ. Trong các ngành nghề khác rất hiếm khi thấy cảnh này. Khi điều tồi tệ xẩy đến, sẽ có những người đến giúp bạn không ngần ngại. Tal Raviv, Gary Smith, Joe Reyes, Toan Dang, Vincent Cheung, Eric Elinow, Abe Marciano và những người khác nữa. Tôi nợ họ cả đời và không gì có thể đền đáp họ được cũng như họ cũng chẳng mong đợi sự đền đáp của tôi.

Bạn bắt đầu nhận ra trong đời, những người may mắn nhất thế giới sẽ chỉ một lần là một phần nào đó của điều gì đó vĩ đại. Biết điều này giúp bạn hợp lý hóa sự toàn tâm của bạn.

Tóm lại, tham gia một công ty startup rất thú vị. Mỗi ngày một khác và đều thú vị cả. Ngay cả khi đó là một ngày tồi tệ cũng vẫn rất thú vị. Biết được rằng các quyết định của bạn không chỉ tác động đến bạn mà còn rất nhiều người khác nữa sẽ là một gánh nặng bạn sẵn sàng chịu đựng hàng ngày còn hơn là không làm chủ được tương lai vận mệnh của mình. Đó là lý do tại sao tôi không thể làm gì khác.

Original Post

Very tough to sleep most nights of the week. Weekends don't mean anything to you anymore. Closing a round of financing is not a relief. It means more people are depending on you to turn their investment into 20 times what they gave you.

It's very difficult to "turn it off". But at the same time, television, movies and vacations become so boring to you when your company's future might be sitting in your inbox or in the results of a new A/B test you decide to run.

You feel guilty when you're doing something you like doing outside of the company. Only through years of wrestling with this internal fight do you recognize how the word "balance" is an art that is just as important as any other skill set you could ever hope to have. You begin to see how valuable creativity is and that you must think differently not only to win, but to see the biggest opportunity. You recognize you get your best ideas when you're not staring at a screen. You see immediate returns on healthy distractions.

You start to respect the Duck. Paddle like hell under the water and be smooth and calm on top where everyone can see you. You learn the hard way that if you lose your cool you lose.

You always ask yourself if I am changing the World in a good way? Are people's lives better for having known me?

You are creative and when you have an idea it has no filter before it becomes a reality. This feeling is why you can't do anything else.

You start to see that the word "entrepreneur" is a personality. It's difficult to talk to your friends that are not risking the same things you are because they are content with not pushing themselves or putting it all out there in the public with the likelihood of failure staring at you everyday. You start to turn a lot of your conversations with relatives into how they might exploit opportunities for profit. Those close to you will view your focus as something completely different because they don't understand. You don't blame them. They can't understand if they haven't done it themselves. It's why you will gravitate towards other entrepreneurs. You will find reward in helping other entrepreneurs. This is my email: paul@ecquire.com. Let me know if I can help you with anything.

Your job is to create a vision, a culture, to get the right people on the bus and to inspire. When you look around at a team that believes in the vision as much as you do and trusts you will do the right thing all the time, it's a feeling that can't be explained. The exponential productivity from great people will always amaze you. It's why finding the right team is the most difficult thing you will do but the most important. This learning will affect your life significantly. You will not settle for things anymore because you will see what is possible when you hold out for the best and push to find people that are the best. You don't have a problem anymore being honest with people about not cutting it.

You start to see that you're a leader and you have to lead or you can't be involved with it at all. You turn down acquisition offers because you need to run the show and you feel like your team is the best in the World and you can do anything with hard work. Quitting is not an option.

You have to be willing to sleep in your car and laugh about it. You have to be able to laugh at many things because when you think of the worse things in the World that could happen to your company, they will happen. Imagine working for something for two years and then have to throw it out completely because you see in one day that it's wrong. You realize that if your team is having fun and can always laugh that you won't die, and in fact, the opposite will happen: you will learn to love the journey and look forward to what you do everyday even at the lowest times. You'll hear not to get too low when things are bad and not to get too high when things are good and you'll even give that advice. But you'll never take it because being in the middle all the time isn't exciting and an even keel is never worth missing out on something worth celebrating. You'll become addicted to finding the hardest challenges because there's a direct relationship between how difficult something is and the euphoria of a feeling when you do the impossible.

You realize that it's much more fun when you didn't have money and that money might be the worse thing you could have as a personal goal. If you're lucky enough to genuinely feel this way, it is a surreal feeling that is the closest thing to peace because you realize it's the challenges and the work that you love. Your currencies are freedom, autonomy, responsibility and recognition. Those happen to be the same currencies of the people you want around you.

You feel like a parent to your customers in that they will never realize how much you love them and it is they who validate you are not crazy. You want to hug every one of them. They mean the World to you.

You learn the most about yourself more than any other vocation as an entrepreneur. You learn what you do when you get punched in the face many many times. You learn what you do when no one is looking and when no one would find out. You learn that you are bad at many things, lucky if you're good at a handful of things and the only thing you can ever be great at is being yourself which is why you can never compromise it. You learn how power and recognition can be addicting and see how it could corrupt so many.

You become incredibly grateful for the times that things were going as bad as they possibly could. Most people won't get to see this in any other calling. When things are really bad, there are people that come running to help and don't think twice about it. Tal Raviv, Gary Smith, Joe Reyes, Toan Dang, Vincent Cheung, Eric Elinow, Abe Marciano are some of them. I will forever be in their debt and I could never repay them nor would they want or expect to be repaid.

You begin to realize that in life, the luckiest people in the World only get one shot at being a part of something great. Knowing this helps you make sense of your commitment.

Of all the things said though, it's exciting. Every day is different and so exciting. Even when it's bad it's exciting. Knowing that your decisions will not only affect you but many others is a weight that I would rather have any day than the weight of not controlling my future. That's why I could not do anything else.

Source: Quora

• You can handle the entire software development life cycle, end to end
• You lead others, or others look to you for guidance.
• You can self manage your projects

Software development is a curious creature unlike other fields. Sometimes, a fresh punk out of college can run circles around veterans who have 20+ years of "experience". Programming is a bizarre world where code is king.

Some achieve the above in 2 years or less, others take 10 years. ¹

How

Software engineering is hard. The industry is always changing and you need to keep up with it. You need to put constant effort and time. There is always more to learn than you can possibly absorb. Many engineers who finish a several month boot camp don’t realize how much more they need to learn on top of it. No worries, there is a clear path to becoming a senior software engineer in almost any area of software development. ²

Step 0: choose your path and stick to it!

do one thing and do it well Doug McIlroy : Unix Philosophy

I can’t emphasize this enough! It is really important to choose a specialty and a technical stack that you will be working with. Sticking to it and not getting distracted is what will make you a specialist. It’s an important choice to make. Here is how to do it:

• Choose your specialty. It’s what you want to do. For example: Web development or Mobile development or DevOps etc.
• Choose a technical stack within your specialty. For example: if you chose web development, you’ll need to choose between Ruby on Rails, Python and Django, JavaScript and MEAN etc. If you chose mobile, you’ll need to choose between iOS or Android, etc.
• Stick to it and master it.

I’m not saying that you shouldn’t get familiar with anything else outside of your main specialty. A well rounded T-Shaped Software Engineer knows about other aspects of programming too. Although he/she knows their main specialty extremely well. Now that you’ve chosen your specialty, you have a lot of things to learn. Take your time. It will take you several years to read all these books and practice necessary skills. Get through this challenge one skill at the time. I’ll be using the following technical stacks going forward: Ruby on Rails for web development, iOS for mobile development. It is just because I have experience working with it. I can speak to it personally. At the end of the says it’s just a matter of taste. If you choose some other stack, you’ll need to find different books.

Step 1. Lay the foundations

Read The Pragmatic Programmer book. It’s a good starting point on the path to software mastery. The book summarizes best high level practices. It’s language / technology agnostic. It doesn’t matter which tech stack you choose, the main principles stay the same.

Step 2. Master your programming language

You’ll be using many languages day to day depending on the technology stack of your choice. Although, majority of your code will be written in one language. For example: a Ruby on Rails developer uses Ruby primarily. An AngularJS developer uses JavaScript most of the time. Identifying the language of your choice and mastering it is crucial for your career. Learn it, master it! You’ll be using this language every day. Choose your language and read an advance book on it.

• For a Ruby Developer - Programming
• Ruby For an iOS Developer - The Swift Programming Language

Step 3. Learn your framework

Choose one, learn it:

• For a Rails Developer - Rails Tutorial by Michael Hartl
• For an iOS Developer - iOS programming: The Big Nerd Ranch Guide

Step 4. Become a master of your text editor / IDE

Again. Choose one, master it and stick to it. If you chose VIM, stay with VIM and become a master of it.

Step 5. Use your Version Control System like a pro

I recommend using Git. Here is the resource that I like: Pro git - free online ebook with a complete breakdown on every aspect of git

Step 6. Commit to doing Test Driven Development

Choose a book specific to your tech stack, learn it. Get into a habit of doing it every day. Quality code comes with writing tests.

• For a Ruby on Rails Developer - Rails Test Prescriptions
• For an iOS Developer - Test Driven iOS Development

Step 7. Refactor as a habit

The codebase grows in complexity as you add more functionality. In order to keep your codebase manageable you need to refactor. If you don’t refactor as you go, you’ll soon come to a sad place where even a small change is hard, bugs are inevitable and nobody wants to deal with your messy codebase. Just make your life easier. Don’t delay your refactor. Get into a habit of refactoring. Here is a good book on how to do it: Refactoring: Improving the Design of Existing Code by Martin Fowler

Step 8. Learn software architecture

Depending on the stack you choose, find a good book on architecture. Here is one that I recommend by Martin Fowler. It’s called Patterns of Enterprise Application Architecture

Step 9. Unleash the power of the command line

The command line can feel intimidating at first. Although, as soon as you learn how to use it, you’ll become a lot more efficient in performing basic tasks. That alone makes you a better developer since you are able to achieve more in less time. Then you can take it to the next level. Use shell to automate common tasks and build your dotfiles. If you’re working on a Mac or any Linux distribution, learn shell. Here is a good book on it by Mark Bates: Conquering the Command Line

Step 10. Code code code!

Every single day. Like in any sport, you need to practice what you learned in order for knowledge to stick.

Takeaway

Yes, becoming Senior Software Engineer is hard. It takes a lot of time and commitment. Different people learn at different speed, but on average, it takes about 10 years to become a solid senior dev. It’s a big investment in time for a big return. Software Engineers have the bright future. They are in high demand on the job market. Their salary grows proportionally with their experience. It’s a rapidly growing and a relatively new field. Every day of a software engineer is a challenge. A challenge of changing people’s lives. Go ahead and take on this challenge by becoming a Senior Software Engineer one skill at the time.

And to me, title is just title. It can be your past experience. It can be your new goal. But you need to prove that you're worth it.

The startup, in common sense, is founded to solve people problems, real problems; to provide works for society, also to bring values and make money. That is a thing that people called the vision, team vision, company vision. As the team member, you should understand it clearly, love it or hate it and follow it, make it your life, your working purpose. A team does not need employees but contributors.

The team still need heroes, and there should be an 'I' in the team but the only way to make the boat go fast is perfect coordination, it also means perfect teamwork and synchronization. The skill set is essential, but it isn't important as vision and coordination. The 'I' must be unselfish and think about the team first. As a team member, it’s important to remember that no one is perfect; everyone has something that they could improve upon, including yourself. So, be supportive. Offer constructive criticism. Listen, listen, listen. People who always talk, but never listen will be stunted in growth. Remember that everyone knows something you don’t know.

We effectively have an environment in which competition and collaboration co-exist and feed off each other. Competition, synchronization or collaborating perfectly; make the boat go fast is always the main point. Remember, even if you work harder than anyone else, if you lose synchronization, you slow the boat down.

*They told me there is no “I” in the team.*

I am an athlete.
I am an individual.
I am strong.
I am weak.
I have desires, hopes, and dreams.
I have goals.
I have fears.
As a team, my opponent will never see my weaknesses.
Only my strength, never my fears, only my goals as they unfold before them.
I am not afraid that my team will see my fears, my hopes, dreams, or desires. 
I trust them to an unlimited level.
I am not afraid that my team will see my faults, because
With them I can overcome my faults, with them I am 
fearless, with them I have hopes and dreams.
With my team I am not weak, I do not have the strength
of one athlete, but many, combined, focused, 
And dangerous to my un-united opponent.
I become my team, and my team becomes me.
I do not judge, and I am not judged.
I have a goal, and the team has a goal.
The team goal is my goal.
All that matters is that the team reaches its goal.
They always told me there is no “I” in “Team”.
They were wrong.
I am the team.
I became the team.
The team became me.
The team becomes an entity unto itself.
The team is strong, creative, compassionate, caring,
Authoritative, disciplined.
The team absorbs “I”, and then there is “I” in “Team”.
The “I” becomes part of something much more powerful.

They were right there is no “I” in “Team”,
But there is “Team” in me.