Wednesday, 28 January 2015

SEO Engineering vs. SEO Magic

Don’t we all hate it when people think of SEO as a magic wand?

“Make my site rank on top of Google!”“How much do you take for SEO?”“I want more traffic! More leads! And more online sales, do your thing... and I will pay you 300$ a month!” 

And the scenarios never end!!!

There are hundreds of different ways to do SEO, including sitemaps, link-building, and search-engine-friendly site design and so on. The best strategy for successful SEO can differ by product, by page and even by season. Identifying what works best for each case is what really shows results. In many times, well-known strategies for SEO may not work for a client, while certain tactics that may not be expected for them could work like a charm.

The bottom line is, an SEO specialist is not a magician but an Architect or an Engineer.

  • We are directors, we orchestrate the whole online existence of the business and integrate it to physical life.
  • We are marketing specialists, we design and draw marketing strategies, segmentation, targeting, and positioning.
  • We are analysts, we research the market, identify strengths, weakness, opportunities and threats.
  • We are detectives, we spy on competitors and monitor the brand’s mentions and reputation
  • We are Financial Analysts, we know how to calculate the Time value for money (i.e. the future value of a present investment)
  • We are Brokers, we buy and sell (online) real-estate and placements all the time.
  • We are problem solvers and crises managers, when a new algorithm hits, we know how to contain it and recover the site and protect the business. 
  • We are the Big Brother, we oversee the big data world of numbers, internet traffic distribution, traffic flows, channels, Trends, and daily buzz.



We may not be Magicians, But we definitely are... Supermen and Women

SEOs and online marketers are supermen and women
SEOs are Supermen

Tuesday, 27 January 2015

Differences Between Responsive Design, Dynamic Serving, and a Separate Mobile Site

There are many ways to configure a website for all screens. Factors to think about include the cost, time to build, your available human resources and infrastructure, and the needs of your customers.
Whatever configuration you choose, as an underlying principle we strongly recommend that you serve all your sites from a single domain, like example.com. In particular, if your desktop site is hosted on example.com, don’t put your mobile site on a separate domain, like a.com/example.
Stay with a single domain and you’ll build brand and URL equity with your users. With that principle in mind, let’s look at the three basic ways you can build a mobile-friendly website: responsive designdynamic serving, and a fully separate mobile site.

Responsive Design

Responsive web design (RWD for short) is a clever design technique that uses a single HTML code base for all platforms. That is, all viewing devices read from the same code on the same URL.  The content resizes itself to fit the screen being used, based on pre-defined breakpoints and fluid grids.
RWD requires solid up-front planning. Costs can be high at first, but once the device-specific strategy is set, maintenance can be less resource-intensive.
Pros:
·        One URL for all content. Using a single URL for a piece of content makes it easier for your users to interact with, share, and link to your content. It’s also easier for search engines to discover and index your content.
·        A streamlined user experience. Presentation of all content is customized, and device-specific features can still be used.
·        Flexible orientation. RWD naturally allows for landscape or portrait device orientation changes by users.
·        No redirects. Load time is reduced and performance increased.
Cons:
·        Careful planning required. Since all HTML is shared here, careful planning is a must to develop a truly custom and robust experience with optimal performance for each device and user.
Common mistakes to avoid:
·        Data bloat. Don’t let mobile users download full-size images meant for big screens and fast speeds. Try to reduce HTTP requests and minimize CSS and JavaScript. Load visible content first and defer everything else.
Who it’s for:
Businesses that are focused on offering a consistent experience and can plan holistically for all devices with a single web team. (Starbucks.com, BostonGlobe.com and Time.com all use this approach.) RWD can be expanded to fit new devices as they emerge, and the single URL is good for linking and sharing articles without confusion or redirects.

Dynamic Serving

In this method, the web server detects the type of device a visitor is using, then presents a custom page designed just for that device. Custom pages can be designed for any device type, from mobile phones and tablets to smart TVs.
Pros:
·        A custom user experience. Each user gets content and layout created just for their device.
·        Easier changes. Adjust content or layout for one screen size without having to touch other versions.
·        Faster loading. Your team can streamline content for optimal load times on each device.
·        Single URL. As with Responsive Design, Dynamic Serving keeps all your users on a single URL.
Cons:
·        Content forking. Multiple custom pages mean multiple sets of the same content. Unless you have a sophisticated CMS in place, keeping content up to date on all device-specific pages can be challenging.
Common mistakes:
·        Faulty device detection. Your servers will need to run scripts to recognize all available devices. This step prevents problems like the server sending a mobile-optimized site to tablet users. Your webmaster will need to keep the directory up-to-date and running smoothly to avoid bad detection or gaps in service. Another common mistake is that the server assumes a device orientation, most commonly portrait, but the user may be holding the device in a different orientation (ie landscape).
·        Changing experiences: Users will be confused if you have multiple sites and they appear radically different. While it’s important to customize for each screen size, your brand look and feel should be recognizable in all formats.
Who it’s for:
Dynamic serving is a resource-intensive solution for companies that make frequent changes to their website, and who often need to adjust display for one device, such as tweaking only their mobile site. A capable IT staff (or vendor) is a must to manage the different and possibly complex sets of website code required.

A Separate Mobile Site

A third option is to simply create a mobile site that’s separate from your original desktop site. Your system detects mobile visitors and redirects them to your mobile-optimized site (often using a sub-domain like m.yourname.com).
Only mobile users will see the separate mobile site. Users of tablets, Web-enabled TVs or other devices will still see your original desktop site.
Pros:
·        A custom user experience. This gives you the most freedom to create a separate mobile site that is designed only for mobile users.
·        Easier changes. Content or design changes can be limited to the mobile version of the site, with no effect on other devices.
Cons:
·        Multiple URLs. Sharing a web page requires careful redirects and integration between your mobile and non-mobile sites. Redirects also lead to longer page load times.
·        Content forking. Keeping two different sets of content can make data management more complex.
Common mistakes:
·        Faulty redirects. When a mobile user lands on a deep desktop page, make sure they aren’t redirected to your generic mobile homepage. Also important: avoid smartphone-only errors, where a desktop URL redirects to a non-existent mobile URL.
·        Missing annotations. The two-way (“bidirectional”) annotation helps Googlebot discover your content and helps our algorithms understand the relationship between your desktop and mobile pages and treat them correctly.
·        Inconsistent user experience: People who look at your smartphone site should recognize it as the same business they see on your desktop site. This prevents confusion and a bad overall user experience.
Who it’s for:
Businesses that for any reason need to manage their mobile site independently. For instance, some businesses may want to use a different vendor for mobile, or may want a mobile structure that simply wouldn’t be possible with RWD. Since setup is relatively easy and can be quite cost-effective, a separate mobile site can be good for small businesses with more basic site needs.




References:

  1. http://www.google.com/think/multiscreen/start.html
  2. http://www.feedthebot.com/mobile/ 
  3. https://developers.google.com/webmasters/mobile-sites/
  4. http://www.foraker.com/choosing-between-responsive-web-design-and-a-separate-mobile-site-to-improve-mobile-visitors%E2%80%99-experience/ 
  5. http://mob.is.it/blog/why-separate-mobile-site-is-usually-better-than-responsive-design 

Friday, 9 January 2015

How to Make The Analytics ROBOT to send virtual traffic To Any Site or Track Visits to Your Physical Rooms!!!

Ever wondered how traffic bots work? How come you put any URL in this simple app and you receive thousands and thousands of hits (seen on Analytics) with any parameters or metrics you like.
You can identify which pages receive the traffic, session duration, used device, screen res., even IP, medium, source, etc. So you can actually see in your traffic reports on GA that you've received your traffic from CNN, NY Times, Yahoo, or even Google.

The way such traffic bots work is very simple and straightforward and can used to trigger traffic signals from almost anything.

Here is the HOW it Works:

It sends a 'get request' through the Measurement HTTP Protocol using to GA servers on its URL:

For Example:

http://www.google-analytics.com/collect
?v=1
&tid=UA-xxxxxxxx-x
&cid=123456789
&t=pageview
&dp=/anysubpage





All what you have to do is to put this in the address bar of your browser and press Enter:

http://www.google-analytics.com/collect?v=1&tid=UA-XXXX-Y&cid=555&sr=800x600&t=pageview&dh=mydemo.com&dp=/home&dt=homepage

You can find all the Parameters here: 
https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters 


Now you understood the logic, you can run this request through a very simple app that changes the CID and sends the request automatically via a list of proxies, or instead you can build this small device and... 






YOU CAN TRACK YOUR HOME VISITS WITH GOOGLE ANALYTICS and see how many rooms are visited the most!!



Full details are here: http://nicomiceli.com/tracking-your-home-with-google-analytics/


Resources:

  1. https://developers.google.com/analytics/devguides/collection/protocol/v1/devguide
  2. https://developers.google.com/analytics/devguides/collection/protocol/v1/reference
  3. https://developers.google.com/analytics/devguides/collection/analyticsjs/
  4. http://www.optimizesmart.com/understanding-universal-analytics-measurement-protocol/
  5. http://www.koozai.com/blog/analytics/google-analytics-and-cookies/
  6. http://www.koozai.com/blog/analytics/universal-analytics-and-cookies/

A Checklist Before buying a Used Domain

Whether it is a .com or dot anything, you need to be sure that the domain you are paying a lot of money in is safe and worth every penny you are putting in it.

Buying a used domain is like buying an expensive used car, it may look fancy but you don't know what is under the hood. So, you need to check everything, get a report, and be comfortable knowing that the domain you are driving won't run into an accident in the future because you did not spend one hour doing some check-ups.

The following 14 points is my checklist, you can use it as is, or add more to it if you like:

  1. site: search on the domain name in Google, Bing
  2. info: Search
  3. Google the domain name and check reputation
  4. Keyword search volume, and competition (AdWords KW Planner)
  5. Check the Domain age http://moonsy.com/domain_age/
  6. Check the way back machine at Archive.org
  7. Check robots.txt file and see if archive.org is disabled
  8. Check Backlinks quantity and quality
  9. Check domain and IP health and if it is blacklisted http://mxtoolbox.com/
  10. Check domain and IP health on https://www.ultratools.com/domainHealthReport
  11. Check if blacklisted: http://www.blacklistalert.org/
  12. see if the Domain or IP is currently listed in the live Spamhaus Domain Blocklist (DBL) http://www.spamhaus.org/lookup/
  13. check if it is on DMOZ or Yahoo Dir
  14. Find contact info on Whois.net. If not private, run a search on the contact person 


Wednesday, 7 January 2015

AdWords Scripts Tools and Basics

You do not have to be a programmer to run AdWords Scripts, especially when you manage large E-commerce sites.

I know it is intimidating for many PPC Specialists to deal with code, but when you know the great things you can do with these ready-made scripts and how to implement them as easily as setting up an Ad Group, you will regret not knowing how to do it a long time ago.

First, what can you use the Adwords Scripts for:
There are many things you can use the Scripts for, but the most important are:
  1. Finding broken links in destination URLs
  2. Disabling Ads or Keywords for out of stock items. 
  3. importing data from other CRM tools
  4. Import data from a spreadsheet to make decisions on your AdWords account
  5. Use external inventory data to pause/unpause entities.
  6. As inventory becomes high, you can increase bids or add new keywords.
  7. Automatically take actions against keywords hogging your spend for the day.
  8. Pause the keyword and increase budget at the same time.
  9. Create campaign stats reports and visualizations.
Adwords Scripts infographic what to use it for PPCHero


Adwords Developers page has provided all the needed tools and material you will need in order to run your Scripts. You can find them all here: https://developers.google.com/adwords/scripts/docs/solutions/

Russel Savage has created a nice tutorial that explains the lines you will find in most Scripts:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
/*********************************
* Intro to Javascript For AdWords Scripts
* Version 1.0
* Created By: Russ Savage
* FreeAdWordsScripts.com
*********************************/
function main() {
  // This is a comment. AdWords Scripts ignores this
  /* Here is another way to comment
     that can be used when you need
     to comment multiple lines */
   
  // The main function tells AdWords where to start. You always need
  // at least a main function in your script.
   
  // Let's start with some variables (or primatives)
  // More info on Javascript variables can be found:
  var clubName = 'Fight Club'; // declared with single quotes
  var rule1 = "Don't talk about fight club."; // or double quotes if needed
  var members = 12; // a number, no quotes
  var dues = 3.50; // also a number
  var isAcceptingNewMembers = true; // a boolean, for yes or no answers
   
  // When you need to store multiple values, consider an Array
  // More detailed intro to Arrays can be found here:
  var memberNames = ['brad','edward','robert'];
  // Which you can access the values with an index
  var coolestMember = memberNames[0]; // pronounced member names sub zero
  // 0 is the index of the first element of the array, 1 for the second, etc.
  // We can use the length property of an array to find out how big it is.
  var numberOfMembers = memberNames.length; // this will be 3
  var dailyFights = numberOfMembers*2; // star ( * ) is an operator for multiply
  // so the total number of fights is 6.
  // More on operators can be found here:
  // http://web.eecs.umich.edu/~bartlett/jsops.html
   
  // If you want to group multiple variables together, you can using an Object.
  // An Object is simply a grouping of common variables (and other stuff we'll see later)
  var FightClub = { // The curly brace says group these things together. there is another one at the end.
    clubName : 'The Fight Club', // a string variable. In an Object, we use : instead of = for assignment
    rules : ["Don't talk about fight club.",  // each variable is separated by a comma, instead of a semi-colon
             'Do not talk about fight club.'],
    memberNames : ['brad','eddy','robert','phil','dave'],
    dues : 3.50,
    foundedYear : 1999
  };
  // Now to access the variables inside the object, we use the dot
  Logger.log(FightClub.clubName); // prints The Fight Club
  Logger.log(FightClub.memberNames[0]); // prints brad
   
  // Objects are one of the most important concepts of Javascript and they will come back
  // again and again a little later. More details can be found here:
   
  // Sidebar: Why do I use camelCase for variable names? Technically
  // I could
  var UsEWhaTevERIwanteD = 'but camelCase is easier to read';
  // and conforms to the style guide that Google recommends:
  // Follow the style guide. It helps others read your code.
   
  // If statements (or control statements) allow you to split your code path if needed
  if(numberOfMembers > 10) { // if we have more than 10 members
    dues += 1.00; // increase the dues,
    // plus equals (+=) says "add the value on the right to the value on the left"
  } else { // otherwise
    dues -= 1.00; // decrease the dues
    // there are also -=, *= (multiply), /= (divide by), and %= (modulo equals)
  }
  // Comparison operators like >, <, ==, ===, <=, >= allow you to compare values
  // They return true or false, always
  // Notice the double and triple equal signs. That's not a typo. More info can be found at:
   
  // You can also have multiple if statements and multiple things to test
  if(dues > 5) { // if dues are over $5
    dailyFights++; // increase the fights
  } else if(dues > 2 && dues <= 5) { // if dues are greater than $2, but less than $5
    dailyFights--; // decrease the fights
  } else { // otherwise
    dailyFights = numberOfMembers*2; // reset the fights
  }
  // You'll probably notice none of this makes sense. it is only for example.
  // Double Ampersand && just means AND, || means OR. So in the statement above,
  // both statements with operators must be true in order for the fights to be decreased.
  // Oh, and ++, -- is shortcut for +=1 and -=1 respectively.
   
  // Ok, now lets talk about loops.
  // Here are a few different ways to loop through the members
  // This is called a While Loop and while it might be easy to understand,
  // You won't use it nearly as often as the other two.
  var i = 0; // the variable i is what we will use for each indice
  while(i < memberNames.length) { // while i is less than the length of names
    Logger.log(memberNames[i]); // print out the name
    i++; // and increment the index by 1
  }
  // i is a variable that controls the loop. A common issue with While loops
  // is that you will forget to increment the loop control and you get an infinate loop
   
  // This is the classic For loop
  // The declaration, checking, and incrementing are all done
  // in the first line so it is harder to miss them
  for(var index = 0; index < memberNames.length; index++) {
    Logger.log(memberNames[index]);
  }
   
  // And finally, the easiest loop but hardest to explain, the ForEach loop
  // This is just a variation of the For loop that handles incrementing index
  // behind the scenes so you don't have to.
  for(var index in memberNames) { // declare index, which will be assigned each indice
    Logger.log(memberNames[index]); // Use the indice to print each name
  }
   
  // You can jump out of a loop before it reaches the end by combining the if statement
  for(var index in memberNames) {
    if(memberNames[index] === 'edward') {
      break; // break is a keyword you can use to break out of the loop.
    }
    Logger.log(memberNames[index]);
  }
  // In this case, only the first name is printed because we broke out once we had the
  // second name. More on break and its partner, continue, check out:
   
  // Now let's talk about functions. We have already seen a function in action: main()
  // Functions are groupings of useful code that you can call over and over again easily
  function fight(player1, player2) {
    if(Math.random() < .5) {
      return player1;
    } else {
      return player2; // return means we are going to send player2 back
                      // to the code that called the function
    }
  }
  // This code can be called over and over again using a loop
  for(var player1 in memberNames) { // Loop through each member
    for(var player2 in memberNames) { // Then loop through again
      if(player1 !== player2) { // Players can't fight themselves so check for that
        Logger.log(fight(player1,player2)); // Then call the function we defined earlier
      }
    }
  }
  // This code calls fight() for:
  //    brad vs. edward, brad vs. robert
  //    edward vs. brad, edward vs. robert
  //    robert vs. brad, robert vs. edward
  // Some other functions we have been calling are Logger.log() and Math.random()
  // The cool thing is that as callers of the function, we only need to know how
  // to call the function, we don't need to know how it works behind the scenes
  // For example:
  //   var answer = LargeHadronColider.simulateEleventhDimensionalQuantumThingy(47);
  // Who knows how this works. All we need to know is to send it a number and expect a
  // number back.
   
  // I hope you've been noticing all of the Objects we have been using here. Logger is one,
  // Math is another one (and LargeHadronColider is a fake one). Along with variables, we
  // can also put functions in there as well:
  var FightClub = {
    // ... all that other stuff
    chant : function() {
      Logger.log('His name is Robert Paulson.');
    },
    totalMembers : 5
  };
  // Whoa trippy. So what happens when I call
  FightClub.chant();
  // It's going to print His name is Robert Paulson
   
  // The thing that makes Google AdWords Scripts different from writing just regular Javascript
  // is all of the pre-defined Objects that use functions to interact with AdWords.
  AdWordsApp.currentAccount();
  Utilities.jsonParse('{}');
  AdWordsApp.keywords().withLimit(10).get();
  // How does the above statement work?
  AdWordsApp  // this is a predefined object in AdWords Scripts
    .keywords() // which has a function called keywords() that returns a KeywordSelector object
    .withLimit(10) // which has a function withLimit() that returns the same KeywordSelector object
    .get(); // which has a function get() that returns a KeywordIterator object.
  // Check out the AdWords Scripts documentation to find the objects and classes that make up these calls
   
  // So I think that just about does it for this tutorial.  If you made it this far, awesome! Post a comment to ask
  // any questions you might have.
   
  // Thanks,
  // Russ
}


If you still find it intimidating, or you dont want to waste time copuing and pasting Scripts, there is always Hero Pro by PPC Hero. It costs between 100 to 400 and will take all the Scripting burden off your head.