function buildPersonalWebsite() {
  const developer = new Developer('Enes Arıkan');
  const skills = ['React', 'TypeScript', 'Next.js', 'TailwindCSS'];
  
  developer.setExperience([
    { role: 'QA Engineer', company: 'Insider', years: 2 },
    { role: 'Software Tester', company: 'Various', years: 3 }
  ]);
  
  const projects = developer.createProjects([
    'E-commerce Platform',
    'Task Management App', 
    'Weather Dashboard',
    'Portfolio Website'
  ]);
  
  return {
    portfolio: developer.showcase(projects),
    blog: developer.shareKnowledge(),
    contact: developer.getContactInfo(),
    playground: developer.createInteractiveGames()
  };
}

class CareerJourney {
  constructor() {
    this.levels = [];
    this.currentLevel = 0;
    this.experience = 0;
  }
  
  addExperience(role, company, duration) {
    this.levels.push({
      title: role,
      company: company,
      duration: duration,
      skills: this.getSkillsForRole(role)
    });
    this.levelUp();
  }
  
  levelUp() {
    this.currentLevel++;
    this.experience += 100;
    console.log(`Level up! Now at level ${this.currentLevel}`);
  }
  
  getSkillsForRole(role) {
    const skillMap = {
      'QA Engineer': ['Testing', 'Automation', 'Bug Tracking'],
      'Frontend Developer': ['React', 'JavaScript', 'CSS'],
      'Full Stack Developer': ['Node.js', 'Databases', 'APIs']
    };
    return skillMap[role] || [];
  }
}

// Initialize the journey
const career = new CareerJourney();
career.addExperience('QA Engineer', 'Insider', '2 years');

// Bug hunting mini-game logic
function createBugHunt() {
  const bugs = [
    { type: 'NullPointerException', severity: 'high' },
    { type: 'RaceCondition', severity: 'critical' },
    { type: 'MemoryLeak', severity: 'medium' },
    { type: 'InfiniteLoop', severity: 'high' }
  ];
  
  return {
    findBugs: () => bugs.filter(bug => bug.severity === 'high'),
    fixBug: (bugId) => console.log(`Fixed bug: ${bugId}`),
    score: bugs.length * 10
  };
}

// Skill tree implementation
const skillTree = {
  frontend: {
    react: { level: 5, unlocked: true },
    typescript: { level: 4, unlocked: true },
    nextjs: { level: 4, unlocked: true }
  },
  testing: {
    automation: { level: 5, unlocked: true },
    manual: { level: 5, unlocked: true },
    performance: { level: 3, unlocked: true }
  },
  tools: {
    git: { level: 4, unlocked: true },
    docker: { level: 2, unlocked: false },
    kubernetes: { level: 1, unlocked: false }
  }
};

export default buildPersonalWebsite;
Back to Blog
Person working on an iPhone app representing indie development
December 5, 2024·iOS Development

From Idea to App Store: The Indie Developer's Honest Journey

I've published four iOS apps under Dainty Apps Lab. The gap between 'app works' and 'app is live' is bigger than anyone tells you.

iOSIndie DevApp StoreProduct

I've published four iOS apps under Dainty Apps Lab: Origami Master, Brain Training & Snake Math, Sleep Relaxation Dainty, and a Chrome extension called Mindpoke. Each one taught me something different. Here's the honest version of what that process actually looks like — not the success story, the real one.

The Idea Is the Easy Part

Every app started with a clear idea. Origami Master: guided origami with visual instructions. Brain Training: math puzzles with a Snake-inspired mechanic. Sleep Relaxation: soundscapes and routines for sleep. These felt obvious and useful.

The hard part isn't the idea. It's the 200 small decisions between "this should exist" and "this is live on the App Store." Every one of those decisions either adds polish or adds debt.

Development: What I Didn't Expect to Take So Long

App Store assets: Screenshots, preview videos, app icons in every required size, localized descriptions. This takes longer than most first-time developers budget for, and it directly affects conversion on the product page. I've spent more time on screenshots than on some features.

Edge case handling: What happens when someone denies notification permissions? What if they're on an old iPhone with limited storage? What if they're using the app in an unexpected language? Apps that don't handle these gracefully get 1-star reviews.

TestFlight cycles: Internal testing always surfaces things I missed. Then external beta testers surface different things. Then App Review sometimes surfaces something else entirely. Three rounds of iteration after "the app is done" is normal, not exceptional.

App Review: The Unpredictable Gate

Apple's App Review process has a reputation, and it's earned. Here are things that got my apps rejected or delayed:

  • Placeholder text I forgot to remove from a privacy policy link
  • A missing usage description string for an optional camera permission
  • A subscription flow that didn't match the exact wording required in the review guidelines

None of these were product-breaking issues. All of them caused multi-day delays. The lesson: read the App Review Guidelines for your specific feature category before you build it, not after.

Post-Launch Is a Different Job

Most first-time indie developers think launch is the finish line. It's actually the start of a different job.

Responding to reviews: Users who get a response to a 1-star review sometimes update it. Those who don't hear back almost never do.

Crash monitoring: Post-launch crashes on devices you didn't test on are inevitable. A fast turnaround builds trust with early users and reduces the snowball effect of negative reviews.

ASO iteration: App Store Optimization is ongoing. Keywords, screenshots, category placement — small changes compound over time. It's not a launch task; it's a maintenance task.

User feedback as product signal: Reviews tell you what features to build next better than any product brainstorm. The feature requests that appear repeatedly are your roadmap.

What Running Your Own Studio Actually Teaches You

Building and shipping products independently forces a kind of accountability that employment doesn't. When something breaks, there's no team to blame. When something succeeds, there's no team to credit either — the decision chain is short and visible.

The skill I developed most wasn't technical. It was product judgment: the ability to decide what matters enough to fix now and what can wait, what to build and what to cut, what quality means for a given user in a given context.

That judgment is the most transferable thing I've taken from Dainty Apps Lab into my professional QA work.

The Financial Reality

I'm not going to pretend the revenue numbers are impressive. They're not. Building four apps while working professionally is not a path to passive income — it's a path to building skills, a portfolio, and a much more concrete understanding of what makes mobile products succeed.

The ROI is in what you learn, not what you earn. For now.

All four apps are live on the App Store. See the projects page for links and details.